api/ent/ogent/oas_json_gen.go

// Code generated by ogen, DO NOT EDIT.

package ogent

import (
	"math/bits"
	"strconv"
	"time"

	"github.com/go-faster/errors"
	"github.com/go-faster/jx"

	"github.com/ogen-go/ogen/json"
	"github.com/ogen-go/ogen/validate"
)

// Encode implements json.Marshaler.
func (s *CardCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CardCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfCardCreate = [9]string{
	0: "id",
	1: "card",
	2: "skill",
	3: "status",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "created_at",
}

// Decode decodes CardCreate from json.
func (s *CardCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CardCreate to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCardCreate) {
					name = jsonFieldsNameOfCardCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CardCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CardCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CardList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CardList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfCardList = [9]string{
	0: "id",
	1: "card",
	2: "skill",
	3: "status",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "created_at",
}

// Decode decodes CardList from json.
func (s *CardList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CardList to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCardList) {
					name = jsonFieldsNameOfCardList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CardList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CardList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CardOwnerRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CardOwnerRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfCardOwnerRead = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes CardOwnerRead from json.
func (s *CardOwnerRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CardOwnerRead to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardOwnerRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCardOwnerRead) {
					name = jsonFieldsNameOfCardOwnerRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CardOwnerRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CardOwnerRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CardRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CardRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfCardRead = [9]string{
	0: "id",
	1: "card",
	2: "skill",
	3: "status",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "created_at",
}

// Decode decodes CardRead from json.
func (s *CardRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CardRead to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCardRead) {
					name = jsonFieldsNameOfCardRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CardRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CardRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CardUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CardUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfCardUpdate = [9]string{
	0: "id",
	1: "card",
	2: "skill",
	3: "status",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "created_at",
}

// Decode decodes CardUpdate from json.
func (s *CardUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CardUpdate to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCardUpdate) {
					name = jsonFieldsNameOfCardUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CardUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CardUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateCardReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateCardReq) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{

		e.FieldStart("owner")
		e.Int(s.Owner)
	}
}

var jsonFieldsNameOfCreateCardReq = [11]string{
	0:  "password",
	1:  "card",
	2:  "skill",
	3:  "status",
	4:  "token",
	5:  "cp",
	6:  "url",
	7:  "count",
	8:  "author",
	9:  "created_at",
	10: "owner",
}

// Decode decodes CreateCardReq from json.
func (s *CreateCardReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateCardReq to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "password":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "owner":
			requiredBitSet[1] |= 1 << 2
			if err := func() error {
				v, err := d.Int()
				s.Owner = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateCardReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000100,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateCardReq) {
					name = jsonFieldsNameOfCreateCardReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateCardReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateCardReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateGroupReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateGroupReq) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("name")
		e.Str(s.Name)
	}
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.Users != nil {
			e.FieldStart("users")
			e.ArrStart()
			for _, elem := range s.Users {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfCreateGroupReq = [3]string{
	0: "name",
	1: "password",
	2: "users",
}

// Decode decodes CreateGroupReq from json.
func (s *CreateGroupReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateGroupReq to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "name":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Name = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		case "password":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "users":
			if err := func() error {
				s.Users = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Users = append(s.Users, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"users\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateGroupReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateGroupReq) {
					name = jsonFieldsNameOfCreateGroupReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateGroupReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateGroupReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateMaReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateMaReq) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{

		e.FieldStart("owner")
		e.Int(s.Owner)
	}
}

var jsonFieldsNameOfCreateMaReq = [24]string{
	0:  "password",
	1:  "token",
	2:  "limit",
	3:  "count",
	4:  "handle",
	5:  "text",
	6:  "did",
	7:  "avatar",
	8:  "cid",
	9:  "uri",
	10: "cid_root",
	11: "uri_root",
	12: "root",
	13: "rkey",
	14: "bsky_url",
	15: "comment",
	16: "blog",
	17: "blog_url",
	18: "domain",
	19: "host",
	20: "feed",
	21: "updated_at",
	22: "created_at",
	23: "owner",
}

// Decode decodes CreateMaReq from json.
func (s *CreateMaReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateMaReq to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "password":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "owner":
			requiredBitSet[2] |= 1 << 7
			if err := func() error {
				v, err := d.Int()
				s.Owner = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateMaReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b10000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateMaReq) {
					name = jsonFieldsNameOfCreateMaReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateMaReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateMaReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateSevReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateSevReq) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{

		e.FieldStart("owner")
		e.Int(s.Owner)
	}
}

var jsonFieldsNameOfCreateSevReq = [13]string{
	0:  "password",
	1:  "token",
	2:  "limit",
	3:  "count",
	4:  "handle",
	5:  "did",
	6:  "uid",
	7:  "cid",
	8:  "cp",
	9:  "card",
	10: "updated_at",
	11: "created_at",
	12: "owner",
}

// Decode decodes CreateSevReq from json.
func (s *CreateSevReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateSevReq to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "password":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "owner":
			requiredBitSet[1] |= 1 << 4
			if err := func() error {
				v, err := d.Int()
				s.Owner = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateSevReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00010000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateSevReq) {
					name = jsonFieldsNameOfCreateSevReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateSevReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateSevReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateUeReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateUeReq) encodeFields(e *jx.Encoder) {
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{

		e.FieldStart("owner")
		e.Int(s.Owner)
	}
}

var jsonFieldsNameOfCreateUeReq = [20]string{
	0:  "limit",
	1:  "limit_boss",
	2:  "limit_item",
	3:  "password",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "token",
	11: "cp",
	12: "count",
	13: "location_x",
	14: "location_y",
	15: "location_z",
	16: "location_n",
	17: "author",
	18: "created_at",
	19: "owner",
}

// Decode decodes CreateUeReq from json.
func (s *CreateUeReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateUeReq to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "password":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "owner":
			requiredBitSet[2] |= 1 << 3
			if err := func() error {
				v, err := d.Int()
				s.Owner = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateUeReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00001000,
		0b00000000,
		0b00001000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateUeReq) {
					name = jsonFieldsNameOfCreateUeReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateUeReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateUeReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *CreateUserReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *CreateUserReq) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{

		e.FieldStart("password")
		e.Str(s.Password)
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Card != nil {
			e.FieldStart("card")
			e.ArrStart()
			for _, elem := range s.Card {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Ue != nil {
			e.FieldStart("ue")
			e.ArrStart()
			for _, elem := range s.Ue {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Ma != nil {
			e.FieldStart("ma")
			e.ArrStart()
			for _, elem := range s.Ma {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Sev != nil {
			e.FieldStart("sev")
			e.ArrStart()
			for _, elem := range s.Sev {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfCreateUserReq = [54]string{
	0:  "username",
	1:  "did",
	2:  "member",
	3:  "book",
	4:  "manga",
	5:  "badge",
	6:  "bsky",
	7:  "mastodon",
	8:  "delete",
	9:  "handle",
	10: "token",
	11: "password",
	12: "created_at",
	13: "updated_at",
	14: "raid_at",
	15: "server_at",
	16: "egg_at",
	17: "luck",
	18: "luck_at",
	19: "like",
	20: "like_rank",
	21: "like_at",
	22: "fav",
	23: "ten",
	24: "ten_su",
	25: "ten_kai",
	26: "aiten",
	27: "ten_card",
	28: "ten_delete",
	29: "ten_post",
	30: "ten_get",
	31: "ten_at",
	32: "next",
	33: "room",
	34: "model",
	35: "model_at",
	36: "model_attack",
	37: "model_limit",
	38: "model_skill",
	39: "model_mode",
	40: "model_critical",
	41: "model_critical_d",
	42: "game",
	43: "game_test",
	44: "game_end",
	45: "game_account",
	46: "game_lv",
	47: "coin",
	48: "coin_open",
	49: "coin_at",
	50: "card",
	51: "ue",
	52: "ma",
	53: "sev",
}

// Decode decodes CreateUserReq from json.
func (s *CreateUserReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CreateUserReq to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "username":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "password":
			requiredBitSet[1] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.Password = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"password\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		case "card":
			if err := func() error {
				s.Card = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Card = append(s.Card, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "ue":
			if err := func() error {
				s.Ue = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Ue = append(s.Ue, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ue\"")
			}
		case "ma":
			if err := func() error {
				s.Ma = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Ma = append(s.Ma, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ma\"")
			}
		case "sev":
			if err := func() error {
				s.Sev = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Sev = append(s.Sev, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sev\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CreateUserReq")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000001,
		0b00001000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfCreateUserReq) {
					name = jsonFieldsNameOfCreateUserReq[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *CreateUserReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateUserReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *GroupCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *GroupCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("name")
		e.Str(s.Name)
	}
}

var jsonFieldsNameOfGroupCreate = [2]string{
	0: "id",
	1: "name",
}

// Decode decodes GroupCreate from json.
func (s *GroupCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GroupCreate to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Name = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GroupCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfGroupCreate) {
					name = jsonFieldsNameOfGroupCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *GroupCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GroupCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *GroupList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *GroupList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("name")
		e.Str(s.Name)
	}
}

var jsonFieldsNameOfGroupList = [2]string{
	0: "id",
	1: "name",
}

// Decode decodes GroupList from json.
func (s *GroupList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GroupList to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Name = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GroupList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfGroupList) {
					name = jsonFieldsNameOfGroupList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *GroupList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GroupList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *GroupRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *GroupRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("name")
		e.Str(s.Name)
	}
}

var jsonFieldsNameOfGroupRead = [2]string{
	0: "id",
	1: "name",
}

// Decode decodes GroupRead from json.
func (s *GroupRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GroupRead to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Name = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GroupRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfGroupRead) {
					name = jsonFieldsNameOfGroupRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *GroupRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GroupRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *GroupUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *GroupUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("name")
		e.Str(s.Name)
	}
}

var jsonFieldsNameOfGroupUpdate = [2]string{
	0: "id",
	1: "name",
}

// Decode decodes GroupUpdate from json.
func (s *GroupUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GroupUpdate to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Name = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GroupUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfGroupUpdate) {
					name = jsonFieldsNameOfGroupUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *GroupUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GroupUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *GroupUsersList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *GroupUsersList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfGroupUsersList = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes GroupUsersList from json.
func (s *GroupUsersList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GroupUsersList to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode GroupUsersList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfGroupUsersList) {
					name = jsonFieldsNameOfGroupUsersList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *GroupUsersList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *GroupUsersList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListCardOKApplicationJSON as json.
func (s ListCardOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []CardList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListCardOKApplicationJSON from json.
func (s *ListCardOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListCardOKApplicationJSON to nil")
	}
	var unwrapped []CardList
	if err := func() error {
		unwrapped = make([]CardList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem CardList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListCardOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListCardOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListCardOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListGroupOKApplicationJSON as json.
func (s ListGroupOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []GroupList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListGroupOKApplicationJSON from json.
func (s *ListGroupOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListGroupOKApplicationJSON to nil")
	}
	var unwrapped []GroupList
	if err := func() error {
		unwrapped = make([]GroupList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem GroupList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListGroupOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListGroupOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListGroupOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListGroupUsersOKApplicationJSON as json.
func (s ListGroupUsersOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []GroupUsersList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListGroupUsersOKApplicationJSON from json.
func (s *ListGroupUsersOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListGroupUsersOKApplicationJSON to nil")
	}
	var unwrapped []GroupUsersList
	if err := func() error {
		unwrapped = make([]GroupUsersList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem GroupUsersList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListGroupUsersOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListGroupUsersOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListGroupUsersOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListMaOKApplicationJSON as json.
func (s ListMaOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []MaList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListMaOKApplicationJSON from json.
func (s *ListMaOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListMaOKApplicationJSON to nil")
	}
	var unwrapped []MaList
	if err := func() error {
		unwrapped = make([]MaList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem MaList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListMaOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListMaOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListMaOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListSevOKApplicationJSON as json.
func (s ListSevOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []SevList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListSevOKApplicationJSON from json.
func (s *ListSevOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListSevOKApplicationJSON to nil")
	}
	var unwrapped []SevList
	if err := func() error {
		unwrapped = make([]SevList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem SevList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListSevOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListSevOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListSevOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUeOKApplicationJSON as json.
func (s ListUeOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UeList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUeOKApplicationJSON from json.
func (s *ListUeOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUeOKApplicationJSON to nil")
	}
	var unwrapped []UeList
	if err := func() error {
		unwrapped = make([]UeList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UeList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUeOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUeOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUeOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUserCardOKApplicationJSON as json.
func (s ListUserCardOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UserCardList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUserCardOKApplicationJSON from json.
func (s *ListUserCardOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUserCardOKApplicationJSON to nil")
	}
	var unwrapped []UserCardList
	if err := func() error {
		unwrapped = make([]UserCardList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UserCardList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUserCardOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUserCardOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUserCardOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUserMaOKApplicationJSON as json.
func (s ListUserMaOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UserMaList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUserMaOKApplicationJSON from json.
func (s *ListUserMaOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUserMaOKApplicationJSON to nil")
	}
	var unwrapped []UserMaList
	if err := func() error {
		unwrapped = make([]UserMaList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UserMaList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUserMaOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUserMaOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUserMaOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUserOKApplicationJSON as json.
func (s ListUserOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UserList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUserOKApplicationJSON from json.
func (s *ListUserOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUserOKApplicationJSON to nil")
	}
	var unwrapped []UserList
	if err := func() error {
		unwrapped = make([]UserList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UserList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUserOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUserOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUserOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUserSevOKApplicationJSON as json.
func (s ListUserSevOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UserSevList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUserSevOKApplicationJSON from json.
func (s *ListUserSevOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUserSevOKApplicationJSON to nil")
	}
	var unwrapped []UserSevList
	if err := func() error {
		unwrapped = make([]UserSevList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UserSevList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUserSevOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUserSevOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUserSevOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ListUserUeOKApplicationJSON as json.
func (s ListUserUeOKApplicationJSON) Encode(e *jx.Encoder) {
	unwrapped := []UserUeList(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes ListUserUeOKApplicationJSON from json.
func (s *ListUserUeOKApplicationJSON) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ListUserUeOKApplicationJSON to nil")
	}
	var unwrapped []UserUeList
	if err := func() error {
		unwrapped = make([]UserUeList, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem UserUeList
			if err := elem.Decode(d); err != nil {
				return err
			}
			unwrapped = append(unwrapped, elem)
			return nil
		}); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ListUserUeOKApplicationJSON(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ListUserUeOKApplicationJSON) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ListUserUeOKApplicationJSON) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MaCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MaCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfMaCreate = [22]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "created_at",
}

// Decode decodes MaCreate from json.
func (s *MaCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MaCreate to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MaCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfMaCreate) {
					name = jsonFieldsNameOfMaCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MaCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MaCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MaList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MaList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfMaList = [22]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "created_at",
}

// Decode decodes MaList from json.
func (s *MaList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MaList to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MaList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfMaList) {
					name = jsonFieldsNameOfMaList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MaList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MaList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MaOwnerRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MaOwnerRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfMaOwnerRead = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes MaOwnerRead from json.
func (s *MaOwnerRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MaOwnerRead to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MaOwnerRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfMaOwnerRead) {
					name = jsonFieldsNameOfMaOwnerRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MaOwnerRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MaOwnerRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MaRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MaRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfMaRead = [22]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "created_at",
}

// Decode decodes MaRead from json.
func (s *MaRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MaRead to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MaRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfMaRead) {
					name = jsonFieldsNameOfMaRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MaRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MaRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *MaUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *MaUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfMaUpdate = [22]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "created_at",
}

// Decode decodes MaUpdate from json.
func (s *MaUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MaUpdate to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MaUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfMaUpdate) {
					name = jsonFieldsNameOfMaUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *MaUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *MaUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes bool as json.
func (o OptBool) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Bool(bool(o.Value))
}

// Decode decodes bool from json.
func (o *OptBool) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptBool to nil")
	}
	o.Set = true
	v, err := d.Bool()
	if err != nil {
		return err
	}
	o.Value = bool(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptBool) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBool) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes time.Time as json.
func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
	if !o.Set {
		return
	}
	format(e, o.Value)
}

// Decode decodes time.Time from json.
func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptDateTime to nil")
	}
	o.Set = true
	v, err := format(d)
	if err != nil {
		return err
	}
	o.Value = v
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptDateTime) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e, json.EncodeDateTime)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDateTime) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d, json.DecodeDateTime)
}

// Encode encodes int as json.
func (o OptInt) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Int(int(o.Value))
}

// Decode decodes int from json.
func (o *OptInt) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptInt to nil")
	}
	o.Set = true
	v, err := d.Int()
	if err != nil {
		return err
	}
	o.Value = int(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptInt) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Str(string(o.Value))
}

// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptString to nil")
	}
	o.Set = true
	v, err := d.Str()
	if err != nil {
		return err
	}
	o.Value = string(v)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *R400) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *R400) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("code")
		e.Int(s.Code)
	}
	{

		e.FieldStart("status")
		e.Str(s.Status)
	}
	{

		if len(s.Errors) != 0 {
			e.FieldStart("errors")
			e.Raw(s.Errors)
		}
	}
}

var jsonFieldsNameOfR400 = [3]string{
	0: "code",
	1: "status",
	2: "errors",
}

// Decode decodes R400 from json.
func (s *R400) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode R400 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "code":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Code = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Status = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "errors":
			if err := func() error {
				v, err := d.RawAppend(nil)
				s.Errors = jx.Raw(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"errors\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode R400")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfR400) {
					name = jsonFieldsNameOfR400[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *R400) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *R400) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *R404) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *R404) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("code")
		e.Int(s.Code)
	}
	{

		e.FieldStart("status")
		e.Str(s.Status)
	}
	{

		if len(s.Errors) != 0 {
			e.FieldStart("errors")
			e.Raw(s.Errors)
		}
	}
}

var jsonFieldsNameOfR404 = [3]string{
	0: "code",
	1: "status",
	2: "errors",
}

// Decode decodes R404 from json.
func (s *R404) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode R404 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "code":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Code = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Status = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "errors":
			if err := func() error {
				v, err := d.RawAppend(nil)
				s.Errors = jx.Raw(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"errors\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode R404")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfR404) {
					name = jsonFieldsNameOfR404[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *R404) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *R404) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *R409) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *R409) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("code")
		e.Int(s.Code)
	}
	{

		e.FieldStart("status")
		e.Str(s.Status)
	}
	{

		if len(s.Errors) != 0 {
			e.FieldStart("errors")
			e.Raw(s.Errors)
		}
	}
}

var jsonFieldsNameOfR409 = [3]string{
	0: "code",
	1: "status",
	2: "errors",
}

// Decode decodes R409 from json.
func (s *R409) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode R409 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "code":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Code = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Status = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "errors":
			if err := func() error {
				v, err := d.RawAppend(nil)
				s.Errors = jx.Raw(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"errors\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode R409")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfR409) {
					name = jsonFieldsNameOfR409[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *R409) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *R409) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *R500) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *R500) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("code")
		e.Int(s.Code)
	}
	{

		e.FieldStart("status")
		e.Str(s.Status)
	}
	{

		if len(s.Errors) != 0 {
			e.FieldStart("errors")
			e.Raw(s.Errors)
		}
	}
}

var jsonFieldsNameOfR500 = [3]string{
	0: "code",
	1: "status",
	2: "errors",
}

// Decode decodes R500 from json.
func (s *R500) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode R500 to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "code":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Code = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Status = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "errors":
			if err := func() error {
				v, err := d.RawAppend(nil)
				s.Errors = jx.Raw(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"errors\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode R500")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000011,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfR500) {
					name = jsonFieldsNameOfR500[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *R500) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *R500) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SevCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SevCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfSevCreate = [11]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "created_at",
}

// Decode decodes SevCreate from json.
func (s *SevCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SevCreate to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SevCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfSevCreate) {
					name = jsonFieldsNameOfSevCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SevCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SevCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SevList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SevList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfSevList = [11]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "created_at",
}

// Decode decodes SevList from json.
func (s *SevList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SevList to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SevList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfSevList) {
					name = jsonFieldsNameOfSevList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SevList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SevList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SevOwnerRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SevOwnerRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfSevOwnerRead = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes SevOwnerRead from json.
func (s *SevOwnerRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SevOwnerRead to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SevOwnerRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfSevOwnerRead) {
					name = jsonFieldsNameOfSevOwnerRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SevOwnerRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SevOwnerRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SevRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SevRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfSevRead = [11]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "created_at",
}

// Decode decodes SevRead from json.
func (s *SevRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SevRead to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SevRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfSevRead) {
					name = jsonFieldsNameOfSevRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SevRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SevRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SevUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SevUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfSevUpdate = [11]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "created_at",
}

// Decode decodes SevUpdate from json.
func (s *SevUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SevUpdate to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SevUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfSevUpdate) {
					name = jsonFieldsNameOfSevUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SevUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SevUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UeCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UeCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUeCreate = [18]string{
	0:  "id",
	1:  "limit",
	2:  "limit_boss",
	3:  "limit_item",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "created_at",
}

// Decode decodes UeCreate from json.
func (s *UeCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UeCreate to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UeCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUeCreate) {
					name = jsonFieldsNameOfUeCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UeCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UeCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UeList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UeList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUeList = [18]string{
	0:  "id",
	1:  "limit",
	2:  "limit_boss",
	3:  "limit_item",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "created_at",
}

// Decode decodes UeList from json.
func (s *UeList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UeList to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UeList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUeList) {
					name = jsonFieldsNameOfUeList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UeList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UeList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UeOwnerRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UeOwnerRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUeOwnerRead = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes UeOwnerRead from json.
func (s *UeOwnerRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UeOwnerRead to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UeOwnerRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUeOwnerRead) {
					name = jsonFieldsNameOfUeOwnerRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UeOwnerRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UeOwnerRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UeRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UeRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUeRead = [18]string{
	0:  "id",
	1:  "limit",
	2:  "limit_boss",
	3:  "limit_item",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "created_at",
}

// Decode decodes UeRead from json.
func (s *UeRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UeRead to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UeRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUeRead) {
					name = jsonFieldsNameOfUeRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UeRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UeRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UeUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UeUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUeUpdate = [18]string{
	0:  "id",
	1:  "limit",
	2:  "limit_boss",
	3:  "limit_item",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "created_at",
}

// Decode decodes UeUpdate from json.
func (s *UeUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UeUpdate to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UeUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUeUpdate) {
					name = jsonFieldsNameOfUeUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UeUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UeUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateCardReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateCardReq) encodeFields(e *jx.Encoder) {
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.Owner.Set {
			e.FieldStart("owner")
			s.Owner.Encode(e)
		}
	}
}

var jsonFieldsNameOfUpdateCardReq = [9]string{
	0: "card",
	1: "skill",
	2: "status",
	3: "token",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "owner",
}

// Decode decodes UpdateCardReq from json.
func (s *UpdateCardReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateCardReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "owner":
			if err := func() error {
				s.Owner.Reset()
				if err := s.Owner.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateCardReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateCardReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateCardReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateGroupReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateGroupReq) encodeFields(e *jx.Encoder) {
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
	{
		if s.Users != nil {
			e.FieldStart("users")
			e.ArrStart()
			for _, elem := range s.Users {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfUpdateGroupReq = [2]string{
	0: "name",
	1: "users",
}

// Decode decodes UpdateGroupReq from json.
func (s *UpdateGroupReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateGroupReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "name":
			if err := func() error {
				s.Name.Reset()
				if err := s.Name.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"name\"")
			}
		case "users":
			if err := func() error {
				s.Users = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Users = append(s.Users, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"users\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateGroupReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateGroupReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateGroupReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateMaReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateMaReq) encodeFields(e *jx.Encoder) {
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Owner.Set {
			e.FieldStart("owner")
			s.Owner.Encode(e)
		}
	}
}

var jsonFieldsNameOfUpdateMaReq = [22]string{
	0:  "token",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "owner",
}

// Decode decodes UpdateMaReq from json.
func (s *UpdateMaReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateMaReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "owner":
			if err := func() error {
				s.Owner.Reset()
				if err := s.Owner.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateMaReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateMaReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateMaReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateSevReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateSevReq) encodeFields(e *jx.Encoder) {
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Owner.Set {
			e.FieldStart("owner")
			s.Owner.Encode(e)
		}
	}
}

var jsonFieldsNameOfUpdateSevReq = [11]string{
	0:  "token",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "owner",
}

// Decode decodes UpdateSevReq from json.
func (s *UpdateSevReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateSevReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "owner":
			if err := func() error {
				s.Owner.Reset()
				if err := s.Owner.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateSevReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateSevReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateSevReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateUeReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateUeReq) encodeFields(e *jx.Encoder) {
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.Owner.Set {
			e.FieldStart("owner")
			s.Owner.Encode(e)
		}
	}
}

var jsonFieldsNameOfUpdateUeReq = [18]string{
	0:  "limit",
	1:  "limit_boss",
	2:  "limit_item",
	3:  "lv",
	4:  "lv_point",
	5:  "model",
	6:  "sword",
	7:  "card",
	8:  "mode",
	9:  "token",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "owner",
}

// Decode decodes UpdateUeReq from json.
func (s *UpdateUeReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateUeReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "owner":
			if err := func() error {
				s.Owner.Reset()
				if err := s.Owner.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"owner\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateUeReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateUeReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateUeReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UpdateUserReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UpdateUserReq) encodeFields(e *jx.Encoder) {
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Token.Set {
			e.FieldStart("token")
			s.Token.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Card != nil {
			e.FieldStart("card")
			e.ArrStart()
			for _, elem := range s.Card {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Ue != nil {
			e.FieldStart("ue")
			e.ArrStart()
			for _, elem := range s.Ue {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Ma != nil {
			e.FieldStart("ma")
			e.ArrStart()
			for _, elem := range s.Ma {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Sev != nil {
			e.FieldStart("sev")
			e.ArrStart()
			for _, elem := range s.Sev {
				e.Int(elem)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfUpdateUserReq = [51]string{
	0:  "did",
	1:  "member",
	2:  "book",
	3:  "manga",
	4:  "badge",
	5:  "bsky",
	6:  "mastodon",
	7:  "delete",
	8:  "handle",
	9:  "token",
	10: "updated_at",
	11: "raid_at",
	12: "server_at",
	13: "egg_at",
	14: "luck",
	15: "luck_at",
	16: "like",
	17: "like_rank",
	18: "like_at",
	19: "fav",
	20: "ten",
	21: "ten_su",
	22: "ten_kai",
	23: "aiten",
	24: "ten_card",
	25: "ten_delete",
	26: "ten_post",
	27: "ten_get",
	28: "ten_at",
	29: "next",
	30: "room",
	31: "model",
	32: "model_at",
	33: "model_attack",
	34: "model_limit",
	35: "model_skill",
	36: "model_mode",
	37: "model_critical",
	38: "model_critical_d",
	39: "game",
	40: "game_test",
	41: "game_end",
	42: "game_account",
	43: "game_lv",
	44: "coin",
	45: "coin_open",
	46: "coin_at",
	47: "card",
	48: "ue",
	49: "ma",
	50: "sev",
}

// Decode decodes UpdateUserReq from json.
func (s *UpdateUserReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UpdateUserReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "token":
			if err := func() error {
				s.Token.Reset()
				if err := s.Token.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"token\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		case "card":
			if err := func() error {
				s.Card = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Card = append(s.Card, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "ue":
			if err := func() error {
				s.Ue = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Ue = append(s.Ue, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ue\"")
			}
		case "ma":
			if err := func() error {
				s.Ma = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Ma = append(s.Ma, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ma\"")
			}
		case "sev":
			if err := func() error {
				s.Sev = make([]int, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem int
					v, err := d.Int()
					elem = int(v)
					if err != nil {
						return err
					}
					s.Sev = append(s.Sev, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sev\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UpdateUserReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateUserReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateUserReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserCardList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserCardList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Skill.Set {
			e.FieldStart("skill")
			s.Skill.Encode(e)
		}
	}
	{
		if s.Status.Set {
			e.FieldStart("status")
			s.Status.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserCardList = [9]string{
	0: "id",
	1: "card",
	2: "skill",
	3: "status",
	4: "cp",
	5: "url",
	6: "count",
	7: "author",
	8: "created_at",
}

// Decode decodes UserCardList from json.
func (s *UserCardList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserCardList to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "skill":
			if err := func() error {
				s.Skill.Reset()
				if err := s.Skill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"skill\"")
			}
		case "status":
			if err := func() error {
				s.Status.Reset()
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "url":
			if err := func() error {
				s.URL.Reset()
				if err := s.URL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserCardList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserCardList) {
					name = jsonFieldsNameOfUserCardList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserCardList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserCardList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserCreate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserCreate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserCreate = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes UserCreate from json.
func (s *UserCreate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserCreate to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserCreate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserCreate) {
					name = jsonFieldsNameOfUserCreate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserCreate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserCreate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserList = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes UserList from json.
func (s *UserList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserList to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserList) {
					name = jsonFieldsNameOfUserList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserMaList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserMaList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Text.Set {
			e.FieldStart("text")
			s.Text.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Avatar.Set {
			e.FieldStart("avatar")
			s.Avatar.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.URI.Set {
			e.FieldStart("uri")
			s.URI.Encode(e)
		}
	}
	{
		if s.CidRoot.Set {
			e.FieldStart("cid_root")
			s.CidRoot.Encode(e)
		}
	}
	{
		if s.URIRoot.Set {
			e.FieldStart("uri_root")
			s.URIRoot.Encode(e)
		}
	}
	{
		if s.Root.Set {
			e.FieldStart("root")
			s.Root.Encode(e)
		}
	}
	{
		if s.Rkey.Set {
			e.FieldStart("rkey")
			s.Rkey.Encode(e)
		}
	}
	{
		if s.BskyURL.Set {
			e.FieldStart("bsky_url")
			s.BskyURL.Encode(e)
		}
	}
	{
		if s.Comment.Set {
			e.FieldStart("comment")
			s.Comment.Encode(e)
		}
	}
	{
		if s.Blog.Set {
			e.FieldStart("blog")
			s.Blog.Encode(e)
		}
	}
	{
		if s.BlogURL.Set {
			e.FieldStart("blog_url")
			s.BlogURL.Encode(e)
		}
	}
	{
		if s.Domain.Set {
			e.FieldStart("domain")
			s.Domain.Encode(e)
		}
	}
	{
		if s.Host.Set {
			e.FieldStart("host")
			s.Host.Encode(e)
		}
	}
	{
		if s.Feed.Set {
			e.FieldStart("feed")
			s.Feed.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserMaList = [22]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "text",
	5:  "did",
	6:  "avatar",
	7:  "cid",
	8:  "uri",
	9:  "cid_root",
	10: "uri_root",
	11: "root",
	12: "rkey",
	13: "bsky_url",
	14: "comment",
	15: "blog",
	16: "blog_url",
	17: "domain",
	18: "host",
	19: "feed",
	20: "updated_at",
	21: "created_at",
}

// Decode decodes UserMaList from json.
func (s *UserMaList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserMaList to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "text":
			if err := func() error {
				s.Text.Reset()
				if err := s.Text.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"text\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "avatar":
			if err := func() error {
				s.Avatar.Reset()
				if err := s.Avatar.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"avatar\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "uri":
			if err := func() error {
				s.URI.Reset()
				if err := s.URI.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri\"")
			}
		case "cid_root":
			if err := func() error {
				s.CidRoot.Reset()
				if err := s.CidRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid_root\"")
			}
		case "uri_root":
			if err := func() error {
				s.URIRoot.Reset()
				if err := s.URIRoot.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uri_root\"")
			}
		case "root":
			if err := func() error {
				s.Root.Reset()
				if err := s.Root.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"root\"")
			}
		case "rkey":
			if err := func() error {
				s.Rkey.Reset()
				if err := s.Rkey.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rkey\"")
			}
		case "bsky_url":
			if err := func() error {
				s.BskyURL.Reset()
				if err := s.BskyURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky_url\"")
			}
		case "comment":
			if err := func() error {
				s.Comment.Reset()
				if err := s.Comment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"comment\"")
			}
		case "blog":
			if err := func() error {
				s.Blog.Reset()
				if err := s.Blog.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog\"")
			}
		case "blog_url":
			if err := func() error {
				s.BlogURL.Reset()
				if err := s.BlogURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"blog_url\"")
			}
		case "domain":
			if err := func() error {
				s.Domain.Reset()
				if err := s.Domain.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"domain\"")
			}
		case "host":
			if err := func() error {
				s.Host.Reset()
				if err := s.Host.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"host\"")
			}
		case "feed":
			if err := func() error {
				s.Feed.Reset()
				if err := s.Feed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"feed\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserMaList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserMaList) {
					name = jsonFieldsNameOfUserMaList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserMaList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserMaList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserRead) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserRead) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserRead = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes UserRead from json.
func (s *UserRead) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserRead to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserRead")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserRead) {
					name = jsonFieldsNameOfUserRead[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserRead) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserRead) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserSevList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserSevList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.UID.Set {
			e.FieldStart("uid")
			s.UID.Encode(e)
		}
	}
	{
		if s.Cid.Set {
			e.FieldStart("cid")
			s.Cid.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserSevList = [11]string{
	0:  "id",
	1:  "limit",
	2:  "count",
	3:  "handle",
	4:  "did",
	5:  "uid",
	6:  "cid",
	7:  "cp",
	8:  "card",
	9:  "updated_at",
	10: "created_at",
}

// Decode decodes UserSevList from json.
func (s *UserSevList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserSevList to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "uid":
			if err := func() error {
				s.UID.Reset()
				if err := s.UID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"uid\"")
			}
		case "cid":
			if err := func() error {
				s.Cid.Reset()
				if err := s.Cid.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cid\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserSevList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000001,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserSevList) {
					name = jsonFieldsNameOfUserSevList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserSevList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserSevList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserUeList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserUeList) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{
		if s.Limit.Set {
			e.FieldStart("limit")
			s.Limit.Encode(e)
		}
	}
	{
		if s.LimitBoss.Set {
			e.FieldStart("limit_boss")
			s.LimitBoss.Encode(e)
		}
	}
	{
		if s.LimitItem.Set {
			e.FieldStart("limit_item")
			s.LimitItem.Encode(e)
		}
	}
	{
		if s.Lv.Set {
			e.FieldStart("lv")
			s.Lv.Encode(e)
		}
	}
	{
		if s.LvPoint.Set {
			e.FieldStart("lv_point")
			s.LvPoint.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.Sword.Set {
			e.FieldStart("sword")
			s.Sword.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.Mode.Set {
			e.FieldStart("mode")
			s.Mode.Encode(e)
		}
	}
	{
		if s.Cp.Set {
			e.FieldStart("cp")
			s.Cp.Encode(e)
		}
	}
	{
		if s.Count.Set {
			e.FieldStart("count")
			s.Count.Encode(e)
		}
	}
	{
		if s.LocationX.Set {
			e.FieldStart("location_x")
			s.LocationX.Encode(e)
		}
	}
	{
		if s.LocationY.Set {
			e.FieldStart("location_y")
			s.LocationY.Encode(e)
		}
	}
	{
		if s.LocationZ.Set {
			e.FieldStart("location_z")
			s.LocationZ.Encode(e)
		}
	}
	{
		if s.LocationN.Set {
			e.FieldStart("location_n")
			s.LocationN.Encode(e)
		}
	}
	{
		if s.Author.Set {
			e.FieldStart("author")
			s.Author.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserUeList = [18]string{
	0:  "id",
	1:  "limit",
	2:  "limit_boss",
	3:  "limit_item",
	4:  "lv",
	5:  "lv_point",
	6:  "model",
	7:  "sword",
	8:  "card",
	9:  "mode",
	10: "cp",
	11: "count",
	12: "location_x",
	13: "location_y",
	14: "location_z",
	15: "location_n",
	16: "author",
	17: "created_at",
}

// Decode decodes UserUeList from json.
func (s *UserUeList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserUeList to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "limit":
			if err := func() error {
				s.Limit.Reset()
				if err := s.Limit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit\"")
			}
		case "limit_boss":
			if err := func() error {
				s.LimitBoss.Reset()
				if err := s.LimitBoss.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_boss\"")
			}
		case "limit_item":
			if err := func() error {
				s.LimitItem.Reset()
				if err := s.LimitItem.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"limit_item\"")
			}
		case "lv":
			if err := func() error {
				s.Lv.Reset()
				if err := s.Lv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv\"")
			}
		case "lv_point":
			if err := func() error {
				s.LvPoint.Reset()
				if err := s.LvPoint.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"lv_point\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "sword":
			if err := func() error {
				s.Sword.Reset()
				if err := s.Sword.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sword\"")
			}
		case "card":
			if err := func() error {
				s.Card.Reset()
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		case "mode":
			if err := func() error {
				s.Mode.Reset()
				if err := s.Mode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mode\"")
			}
		case "cp":
			if err := func() error {
				s.Cp.Reset()
				if err := s.Cp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cp\"")
			}
		case "count":
			if err := func() error {
				s.Count.Reset()
				if err := s.Count.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"count\"")
			}
		case "location_x":
			if err := func() error {
				s.LocationX.Reset()
				if err := s.LocationX.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_x\"")
			}
		case "location_y":
			if err := func() error {
				s.LocationY.Reset()
				if err := s.LocationY.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_y\"")
			}
		case "location_z":
			if err := func() error {
				s.LocationZ.Reset()
				if err := s.LocationZ.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_z\"")
			}
		case "location_n":
			if err := func() error {
				s.LocationN.Reset()
				if err := s.LocationN.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"location_n\"")
			}
		case "author":
			if err := func() error {
				s.Author.Reset()
				if err := s.Author.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"author\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserUeList")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00000001,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserUeList) {
					name = jsonFieldsNameOfUserUeList[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserUeList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserUeList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *UserUpdate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *UserUpdate) encodeFields(e *jx.Encoder) {
	{

		e.FieldStart("id")
		e.Int(s.ID)
	}
	{

		e.FieldStart("username")
		e.Str(s.Username)
	}
	{
		if s.Did.Set {
			e.FieldStart("did")
			s.Did.Encode(e)
		}
	}
	{
		if s.Member.Set {
			e.FieldStart("member")
			s.Member.Encode(e)
		}
	}
	{
		if s.Book.Set {
			e.FieldStart("book")
			s.Book.Encode(e)
		}
	}
	{
		if s.Manga.Set {
			e.FieldStart("manga")
			s.Manga.Encode(e)
		}
	}
	{
		if s.Badge.Set {
			e.FieldStart("badge")
			s.Badge.Encode(e)
		}
	}
	{
		if s.Bsky.Set {
			e.FieldStart("bsky")
			s.Bsky.Encode(e)
		}
	}
	{
		if s.Mastodon.Set {
			e.FieldStart("mastodon")
			s.Mastodon.Encode(e)
		}
	}
	{
		if s.Delete.Set {
			e.FieldStart("delete")
			s.Delete.Encode(e)
		}
	}
	{
		if s.Handle.Set {
			e.FieldStart("handle")
			s.Handle.Encode(e)
		}
	}
	{
		if s.CreatedAt.Set {
			e.FieldStart("created_at")
			s.CreatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.UpdatedAt.Set {
			e.FieldStart("updated_at")
			s.UpdatedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.RaidAt.Set {
			e.FieldStart("raid_at")
			s.RaidAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ServerAt.Set {
			e.FieldStart("server_at")
			s.ServerAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.EggAt.Set {
			e.FieldStart("egg_at")
			s.EggAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Luck.Set {
			e.FieldStart("luck")
			s.Luck.Encode(e)
		}
	}
	{
		if s.LuckAt.Set {
			e.FieldStart("luck_at")
			s.LuckAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Like.Set {
			e.FieldStart("like")
			s.Like.Encode(e)
		}
	}
	{
		if s.LikeRank.Set {
			e.FieldStart("like_rank")
			s.LikeRank.Encode(e)
		}
	}
	{
		if s.LikeAt.Set {
			e.FieldStart("like_at")
			s.LikeAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Fav.Set {
			e.FieldStart("fav")
			s.Fav.Encode(e)
		}
	}
	{
		if s.Ten.Set {
			e.FieldStart("ten")
			s.Ten.Encode(e)
		}
	}
	{
		if s.TenSu.Set {
			e.FieldStart("ten_su")
			s.TenSu.Encode(e)
		}
	}
	{
		if s.TenKai.Set {
			e.FieldStart("ten_kai")
			s.TenKai.Encode(e)
		}
	}
	{
		if s.Aiten.Set {
			e.FieldStart("aiten")
			s.Aiten.Encode(e)
		}
	}
	{
		if s.TenCard.Set {
			e.FieldStart("ten_card")
			s.TenCard.Encode(e)
		}
	}
	{
		if s.TenDelete.Set {
			e.FieldStart("ten_delete")
			s.TenDelete.Encode(e)
		}
	}
	{
		if s.TenPost.Set {
			e.FieldStart("ten_post")
			s.TenPost.Encode(e)
		}
	}
	{
		if s.TenGet.Set {
			e.FieldStart("ten_get")
			s.TenGet.Encode(e)
		}
	}
	{
		if s.TenAt.Set {
			e.FieldStart("ten_at")
			s.TenAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Next.Set {
			e.FieldStart("next")
			s.Next.Encode(e)
		}
	}
	{
		if s.Room.Set {
			e.FieldStart("room")
			s.Room.Encode(e)
		}
	}
	{
		if s.Model.Set {
			e.FieldStart("model")
			s.Model.Encode(e)
		}
	}
	{
		if s.ModelAt.Set {
			e.FieldStart("model_at")
			s.ModelAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.ModelAttack.Set {
			e.FieldStart("model_attack")
			s.ModelAttack.Encode(e)
		}
	}
	{
		if s.ModelLimit.Set {
			e.FieldStart("model_limit")
			s.ModelLimit.Encode(e)
		}
	}
	{
		if s.ModelSkill.Set {
			e.FieldStart("model_skill")
			s.ModelSkill.Encode(e)
		}
	}
	{
		if s.ModelMode.Set {
			e.FieldStart("model_mode")
			s.ModelMode.Encode(e)
		}
	}
	{
		if s.ModelCritical.Set {
			e.FieldStart("model_critical")
			s.ModelCritical.Encode(e)
		}
	}
	{
		if s.ModelCriticalD.Set {
			e.FieldStart("model_critical_d")
			s.ModelCriticalD.Encode(e)
		}
	}
	{
		if s.Game.Set {
			e.FieldStart("game")
			s.Game.Encode(e)
		}
	}
	{
		if s.GameTest.Set {
			e.FieldStart("game_test")
			s.GameTest.Encode(e)
		}
	}
	{
		if s.GameEnd.Set {
			e.FieldStart("game_end")
			s.GameEnd.Encode(e)
		}
	}
	{
		if s.GameAccount.Set {
			e.FieldStart("game_account")
			s.GameAccount.Encode(e)
		}
	}
	{
		if s.GameLv.Set {
			e.FieldStart("game_lv")
			s.GameLv.Encode(e)
		}
	}
	{
		if s.Coin.Set {
			e.FieldStart("coin")
			s.Coin.Encode(e)
		}
	}
	{
		if s.CoinOpen.Set {
			e.FieldStart("coin_open")
			s.CoinOpen.Encode(e)
		}
	}
	{
		if s.CoinAt.Set {
			e.FieldStart("coin_at")
			s.CoinAt.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfUserUpdate = [49]string{
	0:  "id",
	1:  "username",
	2:  "did",
	3:  "member",
	4:  "book",
	5:  "manga",
	6:  "badge",
	7:  "bsky",
	8:  "mastodon",
	9:  "delete",
	10: "handle",
	11: "created_at",
	12: "updated_at",
	13: "raid_at",
	14: "server_at",
	15: "egg_at",
	16: "luck",
	17: "luck_at",
	18: "like",
	19: "like_rank",
	20: "like_at",
	21: "fav",
	22: "ten",
	23: "ten_su",
	24: "ten_kai",
	25: "aiten",
	26: "ten_card",
	27: "ten_delete",
	28: "ten_post",
	29: "ten_get",
	30: "ten_at",
	31: "next",
	32: "room",
	33: "model",
	34: "model_at",
	35: "model_attack",
	36: "model_limit",
	37: "model_skill",
	38: "model_mode",
	39: "model_critical",
	40: "model_critical_d",
	41: "game",
	42: "game_test",
	43: "game_end",
	44: "game_account",
	45: "game_lv",
	46: "coin",
	47: "coin_open",
	48: "coin_at",
}

// Decode decodes UserUpdate from json.
func (s *UserUpdate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode UserUpdate to nil")
	}
	var requiredBitSet [7]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.ID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "username":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Username = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"username\"")
			}
		case "did":
			if err := func() error {
				s.Did.Reset()
				if err := s.Did.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"did\"")
			}
		case "member":
			if err := func() error {
				s.Member.Reset()
				if err := s.Member.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"member\"")
			}
		case "book":
			if err := func() error {
				s.Book.Reset()
				if err := s.Book.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"book\"")
			}
		case "manga":
			if err := func() error {
				s.Manga.Reset()
				if err := s.Manga.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"manga\"")
			}
		case "badge":
			if err := func() error {
				s.Badge.Reset()
				if err := s.Badge.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"badge\"")
			}
		case "bsky":
			if err := func() error {
				s.Bsky.Reset()
				if err := s.Bsky.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bsky\"")
			}
		case "mastodon":
			if err := func() error {
				s.Mastodon.Reset()
				if err := s.Mastodon.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mastodon\"")
			}
		case "delete":
			if err := func() error {
				s.Delete.Reset()
				if err := s.Delete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delete\"")
			}
		case "handle":
			if err := func() error {
				s.Handle.Reset()
				if err := s.Handle.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"handle\"")
			}
		case "created_at":
			if err := func() error {
				s.CreatedAt.Reset()
				if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "updated_at":
			if err := func() error {
				s.UpdatedAt.Reset()
				if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"updated_at\"")
			}
		case "raid_at":
			if err := func() error {
				s.RaidAt.Reset()
				if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"raid_at\"")
			}
		case "server_at":
			if err := func() error {
				s.ServerAt.Reset()
				if err := s.ServerAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"server_at\"")
			}
		case "egg_at":
			if err := func() error {
				s.EggAt.Reset()
				if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egg_at\"")
			}
		case "luck":
			if err := func() error {
				s.Luck.Reset()
				if err := s.Luck.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck\"")
			}
		case "luck_at":
			if err := func() error {
				s.LuckAt.Reset()
				if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"luck_at\"")
			}
		case "like":
			if err := func() error {
				s.Like.Reset()
				if err := s.Like.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like\"")
			}
		case "like_rank":
			if err := func() error {
				s.LikeRank.Reset()
				if err := s.LikeRank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_rank\"")
			}
		case "like_at":
			if err := func() error {
				s.LikeAt.Reset()
				if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"like_at\"")
			}
		case "fav":
			if err := func() error {
				s.Fav.Reset()
				if err := s.Fav.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fav\"")
			}
		case "ten":
			if err := func() error {
				s.Ten.Reset()
				if err := s.Ten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten\"")
			}
		case "ten_su":
			if err := func() error {
				s.TenSu.Reset()
				if err := s.TenSu.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_su\"")
			}
		case "ten_kai":
			if err := func() error {
				s.TenKai.Reset()
				if err := s.TenKai.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_kai\"")
			}
		case "aiten":
			if err := func() error {
				s.Aiten.Reset()
				if err := s.Aiten.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"aiten\"")
			}
		case "ten_card":
			if err := func() error {
				s.TenCard.Reset()
				if err := s.TenCard.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_card\"")
			}
		case "ten_delete":
			if err := func() error {
				s.TenDelete.Reset()
				if err := s.TenDelete.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_delete\"")
			}
		case "ten_post":
			if err := func() error {
				s.TenPost.Reset()
				if err := s.TenPost.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_post\"")
			}
		case "ten_get":
			if err := func() error {
				s.TenGet.Reset()
				if err := s.TenGet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_get\"")
			}
		case "ten_at":
			if err := func() error {
				s.TenAt.Reset()
				if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ten_at\"")
			}
		case "next":
			if err := func() error {
				s.Next.Reset()
				if err := s.Next.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next\"")
			}
		case "room":
			if err := func() error {
				s.Room.Reset()
				if err := s.Room.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"room\"")
			}
		case "model":
			if err := func() error {
				s.Model.Reset()
				if err := s.Model.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model\"")
			}
		case "model_at":
			if err := func() error {
				s.ModelAt.Reset()
				if err := s.ModelAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_at\"")
			}
		case "model_attack":
			if err := func() error {
				s.ModelAttack.Reset()
				if err := s.ModelAttack.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_attack\"")
			}
		case "model_limit":
			if err := func() error {
				s.ModelLimit.Reset()
				if err := s.ModelLimit.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_limit\"")
			}
		case "model_skill":
			if err := func() error {
				s.ModelSkill.Reset()
				if err := s.ModelSkill.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_skill\"")
			}
		case "model_mode":
			if err := func() error {
				s.ModelMode.Reset()
				if err := s.ModelMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_mode\"")
			}
		case "model_critical":
			if err := func() error {
				s.ModelCritical.Reset()
				if err := s.ModelCritical.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical\"")
			}
		case "model_critical_d":
			if err := func() error {
				s.ModelCriticalD.Reset()
				if err := s.ModelCriticalD.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"model_critical_d\"")
			}
		case "game":
			if err := func() error {
				s.Game.Reset()
				if err := s.Game.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game\"")
			}
		case "game_test":
			if err := func() error {
				s.GameTest.Reset()
				if err := s.GameTest.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_test\"")
			}
		case "game_end":
			if err := func() error {
				s.GameEnd.Reset()
				if err := s.GameEnd.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_end\"")
			}
		case "game_account":
			if err := func() error {
				s.GameAccount.Reset()
				if err := s.GameAccount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_account\"")
			}
		case "game_lv":
			if err := func() error {
				s.GameLv.Reset()
				if err := s.GameLv.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"game_lv\"")
			}
		case "coin":
			if err := func() error {
				s.Coin.Reset()
				if err := s.Coin.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin\"")
			}
		case "coin_open":
			if err := func() error {
				s.CoinOpen.Reset()
				if err := s.CoinOpen.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_open\"")
			}
		case "coin_at":
			if err := func() error {
				s.CoinAt.Reset()
				if err := s.CoinAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"coin_at\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode UserUpdate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [7]uint8{
		0b00000011,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
		0b00000000,
	} {
		if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
			// Mask only required fields and check equality to mask using XOR.
			//
			// If XOR result is not zero, result is not equal to expected, so some fields are missed.
			// Bits of fields which would be set are actually bits of missed fields.
			missed := bits.OnesCount8(result)
			for bitN := 0; bitN < missed; bitN++ {
				bitIdx := bits.TrailingZeros8(result)
				fieldIdx := i*8 + bitIdx
				var name string
				if fieldIdx < len(jsonFieldsNameOfUserUpdate) {
					name = jsonFieldsNameOfUserUpdate[fieldIdx]
				} else {
					name = strconv.Itoa(fieldIdx)
				}
				failures = append(failures, validate.FieldError{
					Name:  name,
					Error: validate.ErrFieldRequired,
				})
				// Reset bit.
				result &^= 1 << bitIdx
			}
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *UserUpdate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UserUpdate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}