// Code generated by ogen, DO NOT EDIT.

package gen

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 encodes AccountId as json.
func (s AccountId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes AccountId from json.
func (s *AccountId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode AccountId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = AccountId(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *AirlineLeg) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("departure_airport")
		e.Str(s.DepartureAirport)
	}
	{
		e.FieldStart("destination_airport")
		e.Str(s.DestinationAirport)
	}
	{
		e.FieldStart("departure_date")
		json.EncodeDate(e, s.DepartureDate)
	}
	{
		if s.CarrierCode.Set {
			e.FieldStart("carrier_code")
			s.CarrierCode.Encode(e)
		}
	}
}

var jsonFieldsNameOfAirlineLeg = [4]string{
	0: "departure_airport",
	1: "destination_airport",
	2: "departure_date",
	3: "carrier_code",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "departure_airport":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.DepartureAirport = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"departure_airport\"")
			}
		case "destination_airport":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.DestinationAirport = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"destination_airport\"")
			}
		case "departure_date":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := json.DecodeDate(d)
				s.DepartureDate = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"departure_date\"")
			}
		case "carrier_code":
			if err := func() error {
				s.CarrierCode.Reset()
				if err := s.CarrierCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"carrier_code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode AirlineLeg")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfAirlineLeg) {
					name = jsonFieldsNameOfAirlineLeg[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 *AirlineLeg) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *AirlinePassenger) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("first_name")
		e.Str(s.FirstName)
	}
	{
		e.FieldStart("last_name")
		e.Str(s.LastName)
	}
}

var jsonFieldsNameOfAirlinePassenger = [2]string{
	0: "first_name",
	1: "last_name",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "first_name":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.FirstName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first_name\"")
			}
		case "last_name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.LastName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last_name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode AirlinePassenger")
	}
	// 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(jsonFieldsNameOfAirlinePassenger) {
					name = jsonFieldsNameOfAirlinePassenger[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 *AirlinePassenger) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *AuthorizationDetails) encodeFields(e *jx.Encoder) {
	{
		if s.Rrn.Set {
			e.FieldStart("rrn")
			s.Rrn.Encode(e)
		}
	}
	{
		if s.AuthCode.Set {
			e.FieldStart("auth_code")
			s.AuthCode.Encode(e)
		}
	}
	{
		e.FieldStart("three_d_secure")
		s.ThreeDSecure.Encode(e)
	}
}

var jsonFieldsNameOfAuthorizationDetails = [3]string{
	0: "rrn",
	1: "auth_code",
	2: "three_d_secure",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "rrn":
			if err := func() error {
				s.Rrn.Reset()
				if err := s.Rrn.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rrn\"")
			}
		case "auth_code":
			if err := func() error {
				s.AuthCode.Reset()
				if err := s.AuthCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"auth_code\"")
			}
		case "three_d_secure":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.ThreeDSecure.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"three_d_secure\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode AuthorizationDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		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(jsonFieldsNameOfAuthorizationDetails) {
					name = jsonFieldsNameOfAuthorizationDetails[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 *AuthorizationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *B2bSberbankCalculatedVatData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("rate")
		s.Rate.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfB2bSberbankCalculatedVatData = [3]string{
	0: "type",
	1: "rate",
	2: "amount",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "rate":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Rate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rate\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankCalculatedVatData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfB2bSberbankCalculatedVatData) {
					name = jsonFieldsNameOfB2bSberbankCalculatedVatData[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 *B2bSberbankCalculatedVatData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *B2bSberbankCalculatedVatDataAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfB2bSberbankCalculatedVatDataAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankCalculatedVatDataAmount")
	}
	// 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(jsonFieldsNameOfB2bSberbankCalculatedVatDataAmount) {
					name = jsonFieldsNameOfB2bSberbankCalculatedVatDataAmount[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 *B2bSberbankCalculatedVatDataAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes B2bSberbankCalculatedVatDataRate as json.
func (s B2bSberbankCalculatedVatDataRate) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes B2bSberbankCalculatedVatDataRate from json.
func (s *B2bSberbankCalculatedVatDataRate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode B2bSberbankCalculatedVatDataRate to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch B2bSberbankCalculatedVatDataRate(v) {
	case B2bSberbankCalculatedVatDataRate5:
		*s = B2bSberbankCalculatedVatDataRate5
	case B2bSberbankCalculatedVatDataRate7:
		*s = B2bSberbankCalculatedVatDataRate7
	case B2bSberbankCalculatedVatDataRate10:
		*s = B2bSberbankCalculatedVatDataRate10
	case B2bSberbankCalculatedVatDataRate20:
		*s = B2bSberbankCalculatedVatDataRate20
	case B2bSberbankCalculatedVatDataRate22:
		*s = B2bSberbankCalculatedVatDataRate22
	default:
		*s = B2bSberbankCalculatedVatDataRate(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *B2bSberbankMixedVatData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfB2bSberbankMixedVatData = [2]string{
	0: "type",
	1: "amount",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankMixedVatData")
	}
	// 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(jsonFieldsNameOfB2bSberbankMixedVatData) {
					name = jsonFieldsNameOfB2bSberbankMixedVatData[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 *B2bSberbankMixedVatData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *B2bSberbankMixedVatDataAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfB2bSberbankMixedVatDataAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankMixedVatDataAmount")
	}
	// 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(jsonFieldsNameOfB2bSberbankMixedVatDataAmount) {
					name = jsonFieldsNameOfB2bSberbankMixedVatDataAmount[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 *B2bSberbankMixedVatDataAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *B2bSberbankPayerBankDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("full_name")
		e.Str(s.FullName)
	}
	{
		e.FieldStart("short_name")
		e.Str(s.ShortName)
	}
	{
		e.FieldStart("address")
		e.Str(s.Address)
	}
	{
		e.FieldStart("inn")
		e.Str(s.Inn)
	}
	{
		e.FieldStart("bank_name")
		e.Str(s.BankName)
	}
	{
		e.FieldStart("bank_branch")
		e.Str(s.BankBranch)
	}
	{
		e.FieldStart("bank_bik")
		e.Str(s.BankBik)
	}
	{
		e.FieldStart("account")
		e.Str(s.Account)
	}
	{
		if s.Kpp.Set {
			e.FieldStart("kpp")
			s.Kpp.Encode(e)
		}
	}
}

var jsonFieldsNameOfB2bSberbankPayerBankDetails = [9]string{
	0: "full_name",
	1: "short_name",
	2: "address",
	3: "inn",
	4: "bank_name",
	5: "bank_branch",
	6: "bank_bik",
	7: "account",
	8: "kpp",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "full_name":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.FullName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"full_name\"")
			}
		case "short_name":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ShortName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"short_name\"")
			}
		case "address":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.Address = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"address\"")
			}
		case "inn":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.Inn = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"inn\"")
			}
		case "bank_name":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				v, err := d.Str()
				s.BankName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_name\"")
			}
		case "bank_branch":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				v, err := d.Str()
				s.BankBranch = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_branch\"")
			}
		case "bank_bik":
			requiredBitSet[0] |= 1 << 6
			if err := func() error {
				v, err := d.Str()
				s.BankBik = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_bik\"")
			}
		case "account":
			requiredBitSet[0] |= 1 << 7
			if err := func() error {
				v, err := d.Str()
				s.Account = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account\"")
			}
		case "kpp":
			if err := func() error {
				s.Kpp.Reset()
				if err := s.Kpp.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"kpp\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankPayerBankDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b11111111,
		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(jsonFieldsNameOfB2bSberbankPayerBankDetails) {
					name = jsonFieldsNameOfB2bSberbankPayerBankDetails[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 *B2bSberbankPayerBankDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *B2bSberbankUntaxedVatData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfB2bSberbankUntaxedVatData = [1]string{
	0: "type",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode B2bSberbankUntaxedVatData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfB2bSberbankUntaxedVatData) {
					name = jsonFieldsNameOfB2bSberbankUntaxedVatData[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 *B2bSberbankUntaxedVatData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes B2bSberbankVatDataType as json.
func (s B2bSberbankVatDataType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes B2bSberbankVatDataType from json.
func (s *B2bSberbankVatDataType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode B2bSberbankVatDataType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch B2bSberbankVatDataType(v) {
	case B2bSberbankVatDataTypeCalculated:
		*s = B2bSberbankVatDataTypeCalculated
	case B2bSberbankVatDataTypeUntaxed:
		*s = B2bSberbankVatDataTypeUntaxed
	case B2bSberbankVatDataTypeMixed:
		*s = B2bSberbankVatDataTypeMixed
	default:
		*s = B2bSberbankVatDataType(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *BadRequest) encodeFields(e *jx.Encoder) {
	{
		if s.Type.Set {
			e.FieldStart("type")
			s.Type.Encode(e)
		}
	}
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Parameter.Set {
			e.FieldStart("parameter")
			s.Parameter.Encode(e)
		}
	}
	{
		if s.RetryAfter.Set {
			e.FieldStart("retry_after")
			s.RetryAfter.Encode(e)
		}
	}
	{
		if s.Code.Set {
			e.FieldStart("code")
			s.Code.Encode(e)
		}
	}
}

var jsonFieldsNameOfBadRequest = [6]string{
	0: "type",
	1: "id",
	2: "description",
	3: "parameter",
	4: "retry_after",
	5: "code",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			if err := func() error {
				s.Type.Reset()
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "parameter":
			if err := func() error {
				s.Parameter.Reset()
				if err := s.Parameter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"parameter\"")
			}
		case "retry_after":
			if err := func() error {
				s.RetryAfter.Reset()
				if err := s.RetryAfter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"retry_after\"")
			}
		case "code":
			if err := func() error {
				s.Code.Reset()
				if err := s.Code.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode BadRequest")
	}

	return nil
}

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

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

// Encode encodes BadRequestCode as json.
func (s BadRequestCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes BadRequestCode from json.
func (s *BadRequestCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BadRequestCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch BadRequestCode(v) {
	case BadRequestCodeInvalidRequest:
		*s = BadRequestCodeInvalidRequest
	default:
		*s = BadRequestCode(v)
	}

	return nil
}

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

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

// Encode encodes BadRequestType as json.
func (s BadRequestType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes BadRequestType from json.
func (s *BadRequestType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BadRequestType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch BadRequestType(v) {
	case BadRequestTypeError:
		*s = BadRequestTypeError
	default:
		*s = BadRequestType(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *BankCard) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("card")
		s.Card.Encode(e)
	}
}

var jsonFieldsNameOfBankCard = [2]string{
	0: "type",
	1: "card",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "card":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Card.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode BankCard")
	}
	// 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(jsonFieldsNameOfBankCard) {
					name = jsonFieldsNameOfBankCard[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 *BankCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *BankCardData) encodeFields(e *jx.Encoder) {
	{
		if s.First6.Set {
			e.FieldStart("first6")
			s.First6.Encode(e)
		}
	}
	{
		e.FieldStart("last4")
		s.Last4.Encode(e)
	}
	{
		e.FieldStart("expiry_year")
		s.ExpiryYear.Encode(e)
	}
	{
		e.FieldStart("expiry_month")
		s.ExpiryMonth.Encode(e)
	}
	{
		e.FieldStart("card_type")
		s.CardType.Encode(e)
	}
	{
		if s.CardProduct.Set {
			e.FieldStart("card_product")
			s.CardProduct.Encode(e)
		}
	}
	{
		if s.IssuerCountry.Set {
			e.FieldStart("issuer_country")
			s.IssuerCountry.Encode(e)
		}
	}
	{
		if s.IssuerName.Set {
			e.FieldStart("issuer_name")
			s.IssuerName.Encode(e)
		}
	}
	{
		if s.Source.Set {
			e.FieldStart("source")
			s.Source.Encode(e)
		}
	}
}

var jsonFieldsNameOfBankCardData = [9]string{
	0: "first6",
	1: "last4",
	2: "expiry_year",
	3: "expiry_month",
	4: "card_type",
	5: "card_product",
	6: "issuer_country",
	7: "issuer_name",
	8: "source",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "first6":
			if err := func() error {
				s.First6.Reset()
				if err := s.First6.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first6\"")
			}
		case "last4":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Last4.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last4\"")
			}
		case "expiry_year":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.ExpiryYear.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_year\"")
			}
		case "expiry_month":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.ExpiryMonth.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_month\"")
			}
		case "card_type":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.CardType.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_type\"")
			}
		case "card_product":
			if err := func() error {
				s.CardProduct.Reset()
				if err := s.CardProduct.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_product\"")
			}
		case "issuer_country":
			if err := func() error {
				s.IssuerCountry.Reset()
				if err := s.IssuerCountry.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_country\"")
			}
		case "issuer_name":
			if err := func() error {
				s.IssuerName.Reset()
				if err := s.IssuerName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_name\"")
			}
		case "source":
			if err := func() error {
				s.Source.Reset()
				if err := s.Source.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"source\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode BankCardData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00011110,
		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(jsonFieldsNameOfBankCardData) {
					name = jsonFieldsNameOfBankCardData[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 *BankCardData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes BankCardDataSource as json.
func (s BankCardDataSource) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes BankCardDataSource from json.
func (s *BankCardDataSource) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardDataSource to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch BankCardDataSource(v) {
	case BankCardDataSourceApplePay:
		*s = BankCardDataSourceApplePay
	case BankCardDataSourceGooglePay:
		*s = BankCardDataSourceGooglePay
	case BankCardDataSourceMirPay:
		*s = BankCardDataSourceMirPay
	default:
		*s = BankCardDataSource(v)
	}

	return nil
}

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

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

// Encode encodes BankCardExpiryMonth as json.
func (s BankCardExpiryMonth) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardExpiryMonth from json.
func (s *BankCardExpiryMonth) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardExpiryMonth to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardExpiryMonth(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardExpiryYear as json.
func (s BankCardExpiryYear) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardExpiryYear from json.
func (s *BankCardExpiryYear) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardExpiryYear to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardExpiryYear(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardFirst6 as json.
func (s BankCardFirst6) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardFirst6 from json.
func (s *BankCardFirst6) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardFirst6 to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardFirst6(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardHolderName as json.
func (s BankCardHolderName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardHolderName from json.
func (s *BankCardHolderName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardHolderName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardHolderName(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardIssuerCountry as json.
func (s BankCardIssuerCountry) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardIssuerCountry from json.
func (s *BankCardIssuerCountry) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardIssuerCountry to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardIssuerCountry(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardIssuerName as json.
func (s BankCardIssuerName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardIssuerName from json.
func (s *BankCardIssuerName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardIssuerName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardIssuerName(unwrapped)
	return nil
}

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

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

// Encode encodes BankCardLast4 as json.
func (s BankCardLast4) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes BankCardLast4 from json.
func (s *BankCardLast4) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardLast4 to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = BankCardLast4(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *BankCardProduct) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("code")
		e.Str(s.Code)
	}
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
}

var jsonFieldsNameOfBankCardProduct = [2]string{
	0: "code",
	1: "name",
}

// Decode decodes BankCardProduct from json.
func (s *BankCardProduct) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardProduct 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.Str()
				s.Code = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode BankCardProduct")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfBankCardProduct) {
					name = jsonFieldsNameOfBankCardProduct[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 *BankCardProduct) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes BankCardType as json.
func (s BankCardType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes BankCardType from json.
func (s *BankCardType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode BankCardType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch BankCardType(v) {
	case BankCardTypeMasterCard:
		*s = BankCardTypeMasterCard
	case BankCardTypeVisa:
		*s = BankCardTypeVisa
	case BankCardTypeMir:
		*s = BankCardTypeMir
	case BankCardTypeUnionPay:
		*s = BankCardTypeUnionPay
	case BankCardTypeJCB:
		*s = BankCardTypeJCB
	case BankCardTypeAmericanExpress:
		*s = BankCardTypeAmericanExpress
	case BankCardTypeDinersClub:
		*s = BankCardTypeDinersClub
	case BankCardTypeDiscoverCard:
		*s = BankCardTypeDiscoverCard
	case BankCardTypeInstaPayment:
		*s = BankCardTypeInstaPayment
	case BankCardTypeInstaPaymentTM:
		*s = BankCardTypeInstaPaymentTM
	case BankCardTypeLaser:
		*s = BankCardTypeLaser
	case BankCardTypeDankort:
		*s = BankCardTypeDankort
	case BankCardTypeSolo:
		*s = BankCardTypeSolo
	case BankCardTypeSwitch:
		*s = BankCardTypeSwitch
	case BankCardTypeUnknown:
		*s = BankCardTypeUnknown
	default:
		*s = BankCardType(v)
	}

	return nil
}

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

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

// Encode encodes Capture as json.
func (s Capture) Encode(e *jx.Encoder) {
	unwrapped := bool(s)

	e.Bool(unwrapped)
}

// Decode decodes Capture from json.
func (s *Capture) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Capture to nil")
	}
	var unwrapped bool
	if err := func() error {
		v, err := d.Bool()
		unwrapped = bool(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Capture(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *CardDataForPayoutDestination) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("number")
		e.Str(s.Number)
	}
}

var jsonFieldsNameOfCardDataForPayoutDestination = [1]string{
	0: "number",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "number":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Number = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardDataForPayoutDestination")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfCardDataForPayoutDestination) {
					name = jsonFieldsNameOfCardDataForPayoutDestination[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 *CardDataForPayoutDestination) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *CardRequestData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("number")
		e.Str(s.Number)
	}
	{
		e.FieldStart("expiry_year")
		e.Str(s.ExpiryYear)
	}
	{
		e.FieldStart("expiry_month")
		e.Str(s.ExpiryMonth)
	}
	{
		if s.Cardholder.Set {
			e.FieldStart("cardholder")
			s.Cardholder.Encode(e)
		}
	}
}

var jsonFieldsNameOfCardRequestData = [4]string{
	0: "number",
	1: "expiry_year",
	2: "expiry_month",
	3: "cardholder",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "number":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Number = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"number\"")
			}
		case "expiry_year":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ExpiryYear = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_year\"")
			}
		case "expiry_month":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.ExpiryMonth = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_month\"")
			}
		case "cardholder":
			if err := func() error {
				s.Cardholder.Reset()
				if err := s.Cardholder.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cardholder\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode CardRequestData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfCardRequestData) {
					name = jsonFieldsNameOfCardRequestData[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 *CardRequestData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ClientIp as json.
func (s ClientIp) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ClientIp from json.
func (s *ClientIp) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ClientIp to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ClientIp(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *Confirmation) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfConfirmation = [1]string{
	0: "type",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Confirmation")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfConfirmation) {
					name = jsonFieldsNameOfConfirmation[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 *Confirmation) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationDataEmbedded) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
}

var jsonFieldsNameOfConfirmationDataEmbedded = [2]string{
	0: "type",
	1: "locale",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationDataEmbedded")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfConfirmationDataEmbedded) {
					name = jsonFieldsNameOfConfirmationDataEmbedded[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 *ConfirmationDataEmbedded) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationDataExternal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
}

var jsonFieldsNameOfConfirmationDataExternal = [2]string{
	0: "type",
	1: "locale",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationDataExternal")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfConfirmationDataExternal) {
					name = jsonFieldsNameOfConfirmationDataExternal[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 *ConfirmationDataExternal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationDataMobileApplication) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
	{
		e.FieldStart("return_url")
		e.Str(s.ReturnURL)
	}
}

var jsonFieldsNameOfConfirmationDataMobileApplication = [3]string{
	0: "type",
	1: "locale",
	2: "return_url",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		case "return_url":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.ReturnURL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationDataMobileApplication")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000101,
	} {
		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(jsonFieldsNameOfConfirmationDataMobileApplication) {
					name = jsonFieldsNameOfConfirmationDataMobileApplication[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 *ConfirmationDataMobileApplication) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationDataQr) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
	{
		if s.ReturnURL.Set {
			e.FieldStart("return_url")
			s.ReturnURL.Encode(e)
		}
	}
}

var jsonFieldsNameOfConfirmationDataQr = [3]string{
	0: "type",
	1: "locale",
	2: "return_url",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		case "return_url":
			if err := func() error {
				s.ReturnURL.Reset()
				if err := s.ReturnURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationDataQr")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfConfirmationDataQr) {
					name = jsonFieldsNameOfConfirmationDataQr[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 *ConfirmationDataQr) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationDataRedirect) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
	{
		if s.Enforce.Set {
			e.FieldStart("enforce")
			s.Enforce.Encode(e)
		}
	}
	{
		e.FieldStart("return_url")
		s.ReturnURL.Encode(e)
	}
}

var jsonFieldsNameOfConfirmationDataRedirect = [4]string{
	0: "type",
	1: "locale",
	2: "enforce",
	3: "return_url",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		case "enforce":
			if err := func() error {
				s.Enforce.Reset()
				if err := s.Enforce.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"enforce\"")
			}
		case "return_url":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.ReturnURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationDataRedirect")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001001,
	} {
		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(jsonFieldsNameOfConfirmationDataRedirect) {
					name = jsonFieldsNameOfConfirmationDataRedirect[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 *ConfirmationDataRedirect) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ConfirmationDataType as json.
func (s ConfirmationDataType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ConfirmationDataType from json.
func (s *ConfirmationDataType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ConfirmationDataType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ConfirmationDataType(v) {
	case ConfirmationDataTypeRedirect:
		*s = ConfirmationDataTypeRedirect
	case ConfirmationDataTypeExternal:
		*s = ConfirmationDataTypeExternal
	case ConfirmationDataTypeQr:
		*s = ConfirmationDataTypeQr
	case ConfirmationDataTypeEmbedded:
		*s = ConfirmationDataTypeEmbedded
	case ConfirmationDataTypeMobileApplication:
		*s = ConfirmationDataTypeMobileApplication
	default:
		*s = ConfirmationDataType(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *ConfirmationEmbedded) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("confirmation_token")
		e.Str(s.ConfirmationToken)
	}
}

var jsonFieldsNameOfConfirmationEmbedded = [2]string{
	0: "type",
	1: "confirmation_token",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "confirmation_token":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ConfirmationToken = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation_token\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationEmbedded")
	}
	// 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(jsonFieldsNameOfConfirmationEmbedded) {
					name = jsonFieldsNameOfConfirmationEmbedded[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 *ConfirmationEmbedded) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationMobileApplication) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("confirmation_url")
		e.Str(s.ConfirmationURL)
	}
}

var jsonFieldsNameOfConfirmationMobileApplication = [2]string{
	0: "type",
	1: "confirmation_url",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "confirmation_url":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ConfirmationURL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationMobileApplication")
	}
	// 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(jsonFieldsNameOfConfirmationMobileApplication) {
					name = jsonFieldsNameOfConfirmationMobileApplication[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 *ConfirmationMobileApplication) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationQr) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("confirmation_data")
		e.Str(s.ConfirmationData)
	}
}

var jsonFieldsNameOfConfirmationQr = [2]string{
	0: "type",
	1: "confirmation_data",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "confirmation_data":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ConfirmationData = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation_data\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationQr")
	}
	// 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(jsonFieldsNameOfConfirmationQr) {
					name = jsonFieldsNameOfConfirmationQr[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 *ConfirmationQr) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ConfirmationRedirect) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Enforce.Set {
			e.FieldStart("enforce")
			s.Enforce.Encode(e)
		}
	}
	{
		if s.ReturnURL.Set {
			e.FieldStart("return_url")
			s.ReturnURL.Encode(e)
		}
	}
	{
		e.FieldStart("confirmation_url")
		s.ConfirmationURL.Encode(e)
	}
}

var jsonFieldsNameOfConfirmationRedirect = [4]string{
	0: "type",
	1: "enforce",
	2: "return_url",
	3: "confirmation_url",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "enforce":
			if err := func() error {
				s.Enforce.Reset()
				if err := s.Enforce.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"enforce\"")
			}
		case "return_url":
			if err := func() error {
				s.ReturnURL.Reset()
				if err := s.ReturnURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		case "confirmation_url":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.ConfirmationURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ConfirmationRedirect")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001001,
	} {
		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(jsonFieldsNameOfConfirmationRedirect) {
					name = jsonFieldsNameOfConfirmationRedirect[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 *ConfirmationRedirect) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ConfirmationType as json.
func (s ConfirmationType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ConfirmationType from json.
func (s *ConfirmationType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ConfirmationType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ConfirmationType(v) {
	case ConfirmationTypeRedirect:
		*s = ConfirmationTypeRedirect
	case ConfirmationTypeExternal:
		*s = ConfirmationTypeExternal
	case ConfirmationTypeQr:
		*s = ConfirmationTypeQr
	case ConfirmationTypeEmbedded:
		*s = ConfirmationTypeEmbedded
	case ConfirmationTypeMobileApplication:
		*s = ConfirmationTypeMobileApplication
	default:
		*s = ConfirmationType(v)
	}

	return nil
}

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

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

// Encode encodes ConfirmationUrl as json.
func (s ConfirmationUrl) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ConfirmationUrl from json.
func (s *ConfirmationUrl) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ConfirmationUrl to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ConfirmationUrl(unwrapped)
	return nil
}

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

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

// Encode encodes CurrencyCode as json.
func (s CurrencyCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes CurrencyCode from json.
func (s *CurrencyCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode CurrencyCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch CurrencyCode(v) {
	case CurrencyCodeRUB:
		*s = CurrencyCodeRUB
	case CurrencyCodeEUR:
		*s = CurrencyCodeEUR
	case CurrencyCodeUSD:
		*s = CurrencyCodeUSD
	case CurrencyCodeKZT:
		*s = CurrencyCodeKZT
	case CurrencyCodeBYN:
		*s = CurrencyCodeBYN
	case CurrencyCodeUAH:
		*s = CurrencyCodeUAH
	case CurrencyCodeUZS:
		*s = CurrencyCodeUZS
	case CurrencyCodeTRY:
		*s = CurrencyCodeTRY
	case CurrencyCodeINR:
		*s = CurrencyCodeINR
	case CurrencyCodeMDL:
		*s = CurrencyCodeMDL
	case CurrencyCodeAZN:
		*s = CurrencyCodeAZN
	case CurrencyCodeAMD:
		*s = CurrencyCodeAMD
	default:
		*s = CurrencyCode(v)
	}

	return nil
}

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

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

// Encode encodes DealId as json.
func (s DealId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes DealId from json.
func (s *DealId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealId(unwrapped)
	return nil
}

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

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

// Encode encodes DealStatus as json.
func (s DealStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes DealStatus from json.
func (s *DealStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch DealStatus(v) {
	case DealStatusOpened:
		*s = DealStatusOpened
	case DealStatusClosed:
		*s = DealStatusClosed
	default:
		*s = DealStatus(v)
	}

	return nil
}

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

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

// Encode encodes DealType as json.
func (s DealType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes DealType from json.
func (s *DealType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch DealType(v) {
	case DealTypeSafeDeal:
		*s = DealTypeSafeDeal
	default:
		*s = DealType(v)
	}

	return nil
}

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

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

// Encode encodes DealsDealIDGetInternalServerError as json.
func (s *DealsDealIDGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsDealIDGetInternalServerError from json.
func (s *DealsDealIDGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsDealIDGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsDealIDGetInternalServerError(unwrapped)
	return nil
}

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

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

// Encode encodes DealsDealIDGetTooManyRequests as json.
func (s *DealsDealIDGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsDealIDGetTooManyRequests from json.
func (s *DealsDealIDGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsDealIDGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsDealIDGetTooManyRequests(unwrapped)
	return nil
}

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

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

// Encode encodes DealsGetInternalServerError as json.
func (s *DealsGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsGetInternalServerError from json.
func (s *DealsGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsGetInternalServerError(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *DealsGetOK) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.NextCursor.Set {
			e.FieldStart("next_cursor")
			s.NextCursor.Encode(e)
		}
	}
}

var jsonFieldsNameOfDealsGetOK = [3]string{
	0: "type",
	1: "items",
	2: "next_cursor",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]SafeDeal, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem SafeDeal
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "next_cursor":
			if err := func() error {
				s.NextCursor.Reset()
				if err := s.NextCursor.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next_cursor\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode DealsGetOK")
	}
	// 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(jsonFieldsNameOfDealsGetOK) {
					name = jsonFieldsNameOfDealsGetOK[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 *DealsGetOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes DealsGetOKType as json.
func (s DealsGetOKType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes DealsGetOKType from json.
func (s *DealsGetOKType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsGetOKType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch DealsGetOKType(v) {
	case DealsGetOKTypeList:
		*s = DealsGetOKTypeList
	default:
		*s = DealsGetOKType(v)
	}

	return nil
}

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

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

// Encode encodes DealsGetTooManyRequests as json.
func (s *DealsGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsGetTooManyRequests from json.
func (s *DealsGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsGetTooManyRequests(unwrapped)
	return nil
}

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

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

// Encode encodes DealsPostInternalServerError as json.
func (s *DealsPostInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsPostInternalServerError from json.
func (s *DealsPostInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsPostInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsPostInternalServerError(unwrapped)
	return nil
}

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

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

// Encode encodes DealsPostTooManyRequests as json.
func (s *DealsPostTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes DealsPostTooManyRequests from json.
func (s *DealsPostTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode DealsPostTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = DealsPostTooManyRequests(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificate) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("certificate_id")
		e.Str(s.CertificateID)
	}
	{
		e.FieldStart("tru_quantity")
		e.Int(s.TruQuantity)
	}
	{
		e.FieldStart("available_compensation")
		s.AvailableCompensation.Encode(e)
	}
	{
		e.FieldStart("applied_compensation")
		s.AppliedCompensation.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificate = [4]string{
	0: "certificate_id",
	1: "tru_quantity",
	2: "available_compensation",
	3: "applied_compensation",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "certificate_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.CertificateID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"certificate_id\"")
			}
		case "tru_quantity":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Int()
				s.TruQuantity = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tru_quantity\"")
			}
		case "available_compensation":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.AvailableCompensation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"available_compensation\"")
			}
		case "applied_compensation":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.AppliedCompensation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"applied_compensation\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfElectronicCertificate) {
					name = jsonFieldsNameOfElectronicCertificate[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 *ElectronicCertificate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateAppliedCompensation) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateAppliedCompensation = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateAppliedCompensation")
	}
	// 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(jsonFieldsNameOfElectronicCertificateAppliedCompensation) {
					name = jsonFieldsNameOfElectronicCertificateAppliedCompensation[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 *ElectronicCertificateAppliedCompensation) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateApprovedPaymentArticle) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("article_number")
		s.ArticleNumber.Encode(e)
	}
	{
		e.FieldStart("tru_code")
		s.TruCode.Encode(e)
	}
	{
		if s.ArticleCode.Set {
			e.FieldStart("article_code")
			s.ArticleCode.Encode(e)
		}
	}
	{
		e.FieldStart("certificates")
		e.ArrStart()
		for _, elem := range s.Certificates {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
}

var jsonFieldsNameOfElectronicCertificateApprovedPaymentArticle = [4]string{
	0: "article_number",
	1: "tru_code",
	2: "article_code",
	3: "certificates",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "article_number":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.ArticleNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_number\"")
			}
		case "tru_code":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.TruCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tru_code\"")
			}
		case "article_code":
			if err := func() error {
				s.ArticleCode.Reset()
				if err := s.ArticleCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_code\"")
			}
		case "certificates":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				s.Certificates = make([]ElectronicCertificate, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ElectronicCertificate
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Certificates = append(s.Certificates, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"certificates\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateApprovedPaymentArticle")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001011,
	} {
		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(jsonFieldsNameOfElectronicCertificateApprovedPaymentArticle) {
					name = jsonFieldsNameOfElectronicCertificateApprovedPaymentArticle[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 *ElectronicCertificateApprovedPaymentArticle) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateArticle) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("article_number")
		s.ArticleNumber.Encode(e)
	}
	{
		e.FieldStart("tru_code")
		s.TruCode.Encode(e)
	}
	{
		if s.ArticleCode.Set {
			e.FieldStart("article_code")
			s.ArticleCode.Encode(e)
		}
	}
	{
		e.FieldStart("article_name")
		e.Str(s.ArticleName)
	}
	{
		e.FieldStart("quantity")
		s.Quantity.Encode(e)
	}
	{
		e.FieldStart("price")
		s.Price.Encode(e)
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfElectronicCertificateArticle = [7]string{
	0: "article_number",
	1: "tru_code",
	2: "article_code",
	3: "article_name",
	4: "quantity",
	5: "price",
	6: "metadata",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "article_number":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.ArticleNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_number\"")
			}
		case "tru_code":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.TruCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tru_code\"")
			}
		case "article_code":
			if err := func() error {
				s.ArticleCode.Reset()
				if err := s.ArticleCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_code\"")
			}
		case "article_name":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.ArticleName = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_name\"")
			}
		case "quantity":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.Quantity.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"quantity\"")
			}
		case "price":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				if err := s.Price.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"price\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateArticle")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00111011,
	} {
		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(jsonFieldsNameOfElectronicCertificateArticle) {
					name = jsonFieldsNameOfElectronicCertificateArticle[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 *ElectronicCertificateArticle) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ElectronicCertificateArticleCode as json.
func (s ElectronicCertificateArticleCode) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ElectronicCertificateArticleCode from json.
func (s *ElectronicCertificateArticleCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ElectronicCertificateArticleCode to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ElectronicCertificateArticleCode(unwrapped)
	return nil
}

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

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

// Encode encodes ElectronicCertificateArticleNumber as json.
func (s ElectronicCertificateArticleNumber) Encode(e *jx.Encoder) {
	unwrapped := int32(s)

	e.Int32(unwrapped)
}

// Decode decodes ElectronicCertificateArticleNumber from json.
func (s *ElectronicCertificateArticleNumber) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ElectronicCertificateArticleNumber to nil")
	}
	var unwrapped int32
	if err := func() error {
		v, err := d.Int32()
		unwrapped = int32(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ElectronicCertificateArticleNumber(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateArticlePrice) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateArticlePrice = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateArticlePrice")
	}
	// 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(jsonFieldsNameOfElectronicCertificateArticlePrice) {
					name = jsonFieldsNameOfElectronicCertificateArticlePrice[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 *ElectronicCertificateArticlePrice) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ElectronicCertificateArticleQuantity as json.
func (s ElectronicCertificateArticleQuantity) Encode(e *jx.Encoder) {
	unwrapped := int32(s)

	e.Int32(unwrapped)
}

// Decode decodes ElectronicCertificateArticleQuantity from json.
func (s *ElectronicCertificateArticleQuantity) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ElectronicCertificateArticleQuantity to nil")
	}
	var unwrapped int32
	if err := func() error {
		v, err := d.Int32()
		unwrapped = int32(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ElectronicCertificateArticleQuantity(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateAvailableCompensation) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateAvailableCompensation = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateAvailableCompensation")
	}
	// 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(jsonFieldsNameOfElectronicCertificateAvailableCompensation) {
					name = jsonFieldsNameOfElectronicCertificateAvailableCompensation[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 *ElectronicCertificateAvailableCompensation) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificatePayment) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("basket_id")
		e.Str(s.BasketID)
	}
}

var jsonFieldsNameOfElectronicCertificatePayment = [2]string{
	0: "amount",
	1: "basket_id",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "basket_id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.BasketID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"basket_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificatePayment")
	}
	// 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(jsonFieldsNameOfElectronicCertificatePayment) {
					name = jsonFieldsNameOfElectronicCertificatePayment[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 *ElectronicCertificatePayment) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificatePaymentAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificatePaymentAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificatePaymentAmount")
	}
	// 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(jsonFieldsNameOfElectronicCertificatePaymentAmount) {
					name = jsonFieldsNameOfElectronicCertificatePaymentAmount[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 *ElectronicCertificatePaymentAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificatePaymentData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("basket_id")
		e.Str(s.BasketID)
	}
}

var jsonFieldsNameOfElectronicCertificatePaymentData = [2]string{
	0: "amount",
	1: "basket_id",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "basket_id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.BasketID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"basket_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificatePaymentData")
	}
	// 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(jsonFieldsNameOfElectronicCertificatePaymentData) {
					name = jsonFieldsNameOfElectronicCertificatePaymentData[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 *ElectronicCertificatePaymentData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificatePaymentDataAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificatePaymentDataAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificatePaymentDataAmount")
	}
	// 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(jsonFieldsNameOfElectronicCertificatePaymentDataAmount) {
					name = jsonFieldsNameOfElectronicCertificatePaymentDataAmount[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 *ElectronicCertificatePaymentDataAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundArticle) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("article_number")
		e.Int32(s.ArticleNumber)
	}
	{
		e.FieldStart("payment_article_number")
		e.Int32(s.PaymentArticleNumber)
	}
	{
		e.FieldStart("tru_code")
		s.TruCode.Encode(e)
	}
	{
		e.FieldStart("quantity")
		e.Int32(s.Quantity)
	}
}

var jsonFieldsNameOfElectronicCertificateRefundArticle = [4]string{
	0: "article_number",
	1: "payment_article_number",
	2: "tru_code",
	3: "quantity",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "article_number":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int32()
				s.ArticleNumber = int32(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"article_number\"")
			}
		case "payment_article_number":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Int32()
				s.PaymentArticleNumber = int32(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_article_number\"")
			}
		case "tru_code":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.TruCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tru_code\"")
			}
		case "quantity":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Int32()
				s.Quantity = int32(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"quantity\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundArticle")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfElectronicCertificateRefundArticle) {
					name = jsonFieldsNameOfElectronicCertificateRefundArticle[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 *ElectronicCertificateRefundArticle) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundDataRequest) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("basket_id")
		e.Str(s.BasketID)
	}
}

var jsonFieldsNameOfElectronicCertificateRefundDataRequest = [2]string{
	0: "amount",
	1: "basket_id",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "basket_id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.BasketID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"basket_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundDataRequest")
	}
	// 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(jsonFieldsNameOfElectronicCertificateRefundDataRequest) {
					name = jsonFieldsNameOfElectronicCertificateRefundDataRequest[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 *ElectronicCertificateRefundDataRequest) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundDataRequestAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateRefundDataRequestAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundDataRequestAmount")
	}
	// 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(jsonFieldsNameOfElectronicCertificateRefundDataRequestAmount) {
					name = jsonFieldsNameOfElectronicCertificateRefundDataRequestAmount[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 *ElectronicCertificateRefundDataRequestAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundDataResponse) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("basket_id")
		e.Str(s.BasketID)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateRefundDataResponse = [2]string{
	0: "basket_id",
	1: "amount",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "basket_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.BasketID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"basket_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundDataResponse")
	}
	// 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(jsonFieldsNameOfElectronicCertificateRefundDataResponse) {
					name = jsonFieldsNameOfElectronicCertificateRefundDataResponse[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 *ElectronicCertificateRefundDataResponse) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundDataResponseAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfElectronicCertificateRefundDataResponseAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundDataResponseAmount")
	}
	// 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(jsonFieldsNameOfElectronicCertificateRefundDataResponseAmount) {
					name = jsonFieldsNameOfElectronicCertificateRefundDataResponseAmount[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 *ElectronicCertificateRefundDataResponseAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundMethod) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.ElectronicCertificate.Set {
			e.FieldStart("electronic_certificate")
			s.ElectronicCertificate.Encode(e)
		}
	}
	{
		if s.Articles != nil {
			e.FieldStart("articles")
			e.ArrStart()
			for _, elem := range s.Articles {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfElectronicCertificateRefundMethod = [3]string{
	0: "type",
	1: "electronic_certificate",
	2: "articles",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "electronic_certificate":
			if err := func() error {
				s.ElectronicCertificate.Reset()
				if err := s.ElectronicCertificate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"electronic_certificate\"")
			}
		case "articles":
			if err := func() error {
				s.Articles = make([]ElectronicCertificateRefundArticle, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ElectronicCertificateRefundArticle
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Articles = append(s.Articles, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"articles\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundMethod")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfElectronicCertificateRefundMethod) {
					name = jsonFieldsNameOfElectronicCertificateRefundMethod[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 *ElectronicCertificateRefundMethod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *ElectronicCertificateRefundMethodData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.ElectronicCertificate.Set {
			e.FieldStart("electronic_certificate")
			s.ElectronicCertificate.Encode(e)
		}
	}
	{
		if s.Articles != nil {
			e.FieldStart("articles")
			e.ArrStart()
			for _, elem := range s.Articles {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfElectronicCertificateRefundMethodData = [3]string{
	0: "type",
	1: "electronic_certificate",
	2: "articles",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "electronic_certificate":
			if err := func() error {
				s.ElectronicCertificate.Reset()
				if err := s.ElectronicCertificate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"electronic_certificate\"")
			}
		case "articles":
			if err := func() error {
				s.Articles = make([]ElectronicCertificateRefundArticle, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ElectronicCertificateRefundArticle
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Articles = append(s.Articles, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"articles\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ElectronicCertificateRefundMethodData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfElectronicCertificateRefundMethodData) {
					name = jsonFieldsNameOfElectronicCertificateRefundMethodData[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 *ElectronicCertificateRefundMethodData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes ElectronicCertificateTruCode as json.
func (s ElectronicCertificateTruCode) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ElectronicCertificateTruCode from json.
func (s *ElectronicCertificateTruCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ElectronicCertificateTruCode to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ElectronicCertificateTruCode(unwrapped)
	return nil
}

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

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

// Encode encodes Enforce as json.
func (s Enforce) Encode(e *jx.Encoder) {
	unwrapped := bool(s)

	e.Bool(unwrapped)
}

// Decode decodes Enforce from json.
func (s *Enforce) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Enforce to nil")
	}
	var unwrapped bool
	if err := func() error {
		v, err := d.Bool()
		unwrapped = bool(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Enforce(unwrapped)
	return nil
}

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

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

// Encode encodes FeeMoment as json.
func (s FeeMoment) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes FeeMoment from json.
func (s *FeeMoment) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FeeMoment to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch FeeMoment(v) {
	case FeeMomentPaymentSucceeded:
		*s = FeeMomentPaymentSucceeded
	case FeeMomentDealClosed:
		*s = FeeMomentDealClosed
	default:
		*s = FeeMoment(v)
	}

	return nil
}

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

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

// Encode encodes FirstName as json.
func (s FirstName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes FirstName from json.
func (s *FirstName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FirstName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = FirstName(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *FiscalizationData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("enabled")
		e.Bool(s.Enabled)
	}
	{
		e.FieldStart("provider")
		s.Provider.Encode(e)
	}
}

var jsonFieldsNameOfFiscalizationData = [2]string{
	0: "enabled",
	1: "provider",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "enabled":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Bool()
				s.Enabled = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"enabled\"")
			}
		case "provider":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Provider.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"provider\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode FiscalizationData")
	}
	// 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(jsonFieldsNameOfFiscalizationData) {
					name = jsonFieldsNameOfFiscalizationData[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 *FiscalizationData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes FiscalizationProvider as json.
func (s FiscalizationProvider) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes FiscalizationProvider from json.
func (s *FiscalizationProvider) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode FiscalizationProvider to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch FiscalizationProvider(v) {
	case FiscalizationProviderAtol:
		*s = FiscalizationProviderAtol
	case FiscalizationProviderAvanpost:
		*s = FiscalizationProviderAvanpost
	case FiscalizationProviderAQsi:
		*s = FiscalizationProviderAQsi
	case FiscalizationProviderBusinessRu:
		*s = FiscalizationProviderBusinessRu
	case FiscalizationProviderDigitalKassa:
		*s = FiscalizationProviderDigitalKassa
	case FiscalizationProviderEvotor:
		*s = FiscalizationProviderEvotor
	case FiscalizationProviderFirstOfd:
		*s = FiscalizationProviderFirstOfd
	case FiscalizationProviderKitInvest:
		*s = FiscalizationProviderKitInvest
	case FiscalizationProviderKomtet:
		*s = FiscalizationProviderKomtet
	case FiscalizationProviderLifePay:
		*s = FiscalizationProviderLifePay
	case FiscalizationProviderMertrade:
		*s = FiscalizationProviderMertrade
	case FiscalizationProviderModulKassa:
		*s = FiscalizationProviderModulKassa
	case FiscalizationProviderRocket:
		*s = FiscalizationProviderRocket
	case FiscalizationProviderShtrihM:
		*s = FiscalizationProviderShtrihM
	default:
		*s = FiscalizationProvider(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *Forbidden) encodeFields(e *jx.Encoder) {
	{
		if s.Type.Set {
			e.FieldStart("type")
			s.Type.Encode(e)
		}
	}
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Parameter.Set {
			e.FieldStart("parameter")
			s.Parameter.Encode(e)
		}
	}
	{
		if s.RetryAfter.Set {
			e.FieldStart("retry_after")
			s.RetryAfter.Encode(e)
		}
	}
	{
		if s.Code.Set {
			e.FieldStart("code")
			s.Code.Encode(e)
		}
	}
}

var jsonFieldsNameOfForbidden = [6]string{
	0: "type",
	1: "id",
	2: "description",
	3: "parameter",
	4: "retry_after",
	5: "code",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			if err := func() error {
				s.Type.Reset()
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "parameter":
			if err := func() error {
				s.Parameter.Reset()
				if err := s.Parameter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"parameter\"")
			}
		case "retry_after":
			if err := func() error {
				s.RetryAfter.Reset()
				if err := s.RetryAfter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"retry_after\"")
			}
		case "code":
			if err := func() error {
				s.Code.Reset()
				if err := s.Code.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Forbidden")
	}

	return nil
}

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

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

// Encode encodes ForbiddenCode as json.
func (s ForbiddenCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ForbiddenCode from json.
func (s *ForbiddenCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ForbiddenCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ForbiddenCode(v) {
	case ForbiddenCodeForbidden:
		*s = ForbiddenCodeForbidden
	default:
		*s = ForbiddenCode(v)
	}

	return nil
}

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

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

// Encode encodes ForbiddenType as json.
func (s ForbiddenType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ForbiddenType from json.
func (s *ForbiddenType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ForbiddenType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ForbiddenType(v) {
	case ForbiddenTypeError:
		*s = ForbiddenTypeError
	default:
		*s = ForbiddenType(v)
	}

	return nil
}

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

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

// Encode encodes GatewayId as json.
func (s GatewayId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes GatewayId from json.
func (s *GatewayId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode GatewayId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = GatewayId(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *IncomeReceipt) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("service_name")
		s.ServiceName.Encode(e)
	}
	{
		if s.NpdReceiptID.Set {
			e.FieldStart("npd_receipt_id")
			s.NpdReceiptID.Encode(e)
		}
	}
	{
		if s.URL.Set {
			e.FieldStart("url")
			s.URL.Encode(e)
		}
	}
	{
		if s.Amount.Set {
			e.FieldStart("amount")
			s.Amount.Encode(e)
		}
	}
}

var jsonFieldsNameOfIncomeReceipt = [4]string{
	0: "service_name",
	1: "npd_receipt_id",
	2: "url",
	3: "amount",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "service_name":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.ServiceName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"service_name\"")
			}
		case "npd_receipt_id":
			if err := func() error {
				s.NpdReceiptID.Reset()
				if err := s.NpdReceiptID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"npd_receipt_id\"")
			}
		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 "amount":
			if err := func() error {
				s.Amount.Reset()
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode IncomeReceipt")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfIncomeReceipt) {
					name = jsonFieldsNameOfIncomeReceipt[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 *IncomeReceipt) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *IncomeReceiptAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfIncomeReceiptAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode IncomeReceiptAmount")
	}
	// 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(jsonFieldsNameOfIncomeReceiptAmount) {
					name = jsonFieldsNameOfIncomeReceiptAmount[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 *IncomeReceiptAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes IncomeReceiptServiceName as json.
func (s IncomeReceiptServiceName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes IncomeReceiptServiceName from json.
func (s *IncomeReceiptServiceName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode IncomeReceiptServiceName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = IncomeReceiptServiceName(unwrapped)
	return nil
}

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

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

// Encode encodes IncomeReceiptUrl as json.
func (s IncomeReceiptUrl) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes IncomeReceiptUrl from json.
func (s *IncomeReceiptUrl) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode IncomeReceiptUrl to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = IncomeReceiptUrl(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *IndustryDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("federal_id")
		e.Str(s.FederalID)
	}
	{
		e.FieldStart("document_date")
		json.EncodeDate(e, s.DocumentDate)
	}
	{
		e.FieldStart("document_number")
		e.Str(s.DocumentNumber)
	}
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
}

var jsonFieldsNameOfIndustryDetails = [4]string{
	0: "federal_id",
	1: "document_date",
	2: "document_number",
	3: "value",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "federal_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.FederalID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"federal_id\"")
			}
		case "document_date":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := json.DecodeDate(d)
				s.DocumentDate = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"document_date\"")
			}
		case "document_number":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.DocumentNumber = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"document_number\"")
			}
		case "value":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode IndustryDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfIndustryDetails) {
					name = jsonFieldsNameOfIndustryDetails[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 *IndustryDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *InvalidCredentials) encodeFields(e *jx.Encoder) {
	{
		if s.Type.Set {
			e.FieldStart("type")
			s.Type.Encode(e)
		}
	}
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Parameter.Set {
			e.FieldStart("parameter")
			s.Parameter.Encode(e)
		}
	}
	{
		if s.RetryAfter.Set {
			e.FieldStart("retry_after")
			s.RetryAfter.Encode(e)
		}
	}
	{
		if s.Code.Set {
			e.FieldStart("code")
			s.Code.Encode(e)
		}
	}
}

var jsonFieldsNameOfInvalidCredentials = [6]string{
	0: "type",
	1: "id",
	2: "description",
	3: "parameter",
	4: "retry_after",
	5: "code",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			if err := func() error {
				s.Type.Reset()
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "parameter":
			if err := func() error {
				s.Parameter.Reset()
				if err := s.Parameter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"parameter\"")
			}
		case "retry_after":
			if err := func() error {
				s.RetryAfter.Reset()
				if err := s.RetryAfter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"retry_after\"")
			}
		case "code":
			if err := func() error {
				s.Code.Reset()
				if err := s.Code.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode InvalidCredentials")
	}

	return nil
}

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

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

// Encode encodes InvalidCredentialsCode as json.
func (s InvalidCredentialsCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes InvalidCredentialsCode from json.
func (s *InvalidCredentialsCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode InvalidCredentialsCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch InvalidCredentialsCode(v) {
	case InvalidCredentialsCodeInvalidCredentials:
		*s = InvalidCredentialsCodeInvalidCredentials
	default:
		*s = InvalidCredentialsCode(v)
	}

	return nil
}

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

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

// Encode encodes InvalidCredentialsType as json.
func (s InvalidCredentialsType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes InvalidCredentialsType from json.
func (s *InvalidCredentialsType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode InvalidCredentialsType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch InvalidCredentialsType(v) {
	case InvalidCredentialsTypeError:
		*s = InvalidCredentialsTypeError
	default:
		*s = InvalidCredentialsType(v)
	}

	return nil
}

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

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

// Encode encodes InvoiceId as json.
func (s InvoiceId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes InvoiceId from json.
func (s *InvoiceId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode InvoiceId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = InvoiceId(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *InvoicingBankCardData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("first6")
		e.Str(s.First6)
	}
	{
		e.FieldStart("last4")
		s.Last4.Encode(e)
	}
	{
		e.FieldStart("expiry_year")
		s.ExpiryYear.Encode(e)
	}
	{
		e.FieldStart("expiry_month")
		s.ExpiryMonth.Encode(e)
	}
	{
		e.FieldStart("card_type")
		s.CardType.Encode(e)
	}
}

var jsonFieldsNameOfInvoicingBankCardData = [5]string{
	0: "first6",
	1: "last4",
	2: "expiry_year",
	3: "expiry_month",
	4: "card_type",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "first6":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.First6 = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first6\"")
			}
		case "last4":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Last4.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last4\"")
			}
		case "expiry_year":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.ExpiryYear.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_year\"")
			}
		case "expiry_month":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.ExpiryMonth.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_month\"")
			}
		case "card_type":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.CardType.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode InvoicingBankCardData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00011111,
	} {
		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(jsonFieldsNameOfInvoicingBankCardData) {
					name = jsonFieldsNameOfInvoicingBankCardData[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 *InvoicingBankCardData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes Kbk as json.
func (s Kbk) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes Kbk from json.
func (s *Kbk) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Kbk to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Kbk(unwrapped)
	return nil
}

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

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

// Encode encodes LastName as json.
func (s LastName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes LastName from json.
func (s *LastName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode LastName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = LastName(unwrapped)
	return nil
}

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

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

// Encode encodes Locale as json.
func (s Locale) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes Locale from json.
func (s *Locale) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Locale to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch Locale(v) {
	case LocaleRuRU:
		*s = LocaleRuRU
	case LocaleEnUS:
		*s = LocaleEnUS
	default:
		*s = Locale(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *MarkCodeInfo) encodeFields(e *jx.Encoder) {
	{
		if s.MarkCodeRaw.Set {
			e.FieldStart("mark_code_raw")
			s.MarkCodeRaw.Encode(e)
		}
	}
	{
		if s.Unknown.Set {
			e.FieldStart("unknown")
			s.Unknown.Encode(e)
		}
	}
	{
		if s.Ean8.Set {
			e.FieldStart("ean_8")
			s.Ean8.Encode(e)
		}
	}
	{
		if s.Ean13.Set {
			e.FieldStart("ean_13")
			s.Ean13.Encode(e)
		}
	}
	{
		if s.Itf14.Set {
			e.FieldStart("itf_14")
			s.Itf14.Encode(e)
		}
	}
	{
		if s.Gs10.Set {
			e.FieldStart("gs_10")
			s.Gs10.Encode(e)
		}
	}
	{
		if s.Gs1m.Set {
			e.FieldStart("gs_1m")
			s.Gs1m.Encode(e)
		}
	}
	{
		if s.Short.Set {
			e.FieldStart("short")
			s.Short.Encode(e)
		}
	}
	{
		if s.Fur.Set {
			e.FieldStart("fur")
			s.Fur.Encode(e)
		}
	}
	{
		if s.Egais20.Set {
			e.FieldStart("egais_20")
			s.Egais20.Encode(e)
		}
	}
	{
		if s.Egais30.Set {
			e.FieldStart("egais_30")
			s.Egais30.Encode(e)
		}
	}
}

var jsonFieldsNameOfMarkCodeInfo = [11]string{
	0:  "mark_code_raw",
	1:  "unknown",
	2:  "ean_8",
	3:  "ean_13",
	4:  "itf_14",
	5:  "gs_10",
	6:  "gs_1m",
	7:  "short",
	8:  "fur",
	9:  "egais_20",
	10: "egais_30",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "mark_code_raw":
			if err := func() error {
				s.MarkCodeRaw.Reset()
				if err := s.MarkCodeRaw.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_code_raw\"")
			}
		case "unknown":
			if err := func() error {
				s.Unknown.Reset()
				if err := s.Unknown.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"unknown\"")
			}
		case "ean_8":
			if err := func() error {
				s.Ean8.Reset()
				if err := s.Ean8.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ean_8\"")
			}
		case "ean_13":
			if err := func() error {
				s.Ean13.Reset()
				if err := s.Ean13.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ean_13\"")
			}
		case "itf_14":
			if err := func() error {
				s.Itf14.Reset()
				if err := s.Itf14.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"itf_14\"")
			}
		case "gs_10":
			if err := func() error {
				s.Gs10.Reset()
				if err := s.Gs10.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gs_10\"")
			}
		case "gs_1m":
			if err := func() error {
				s.Gs1m.Reset()
				if err := s.Gs1m.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gs_1m\"")
			}
		case "short":
			if err := func() error {
				s.Short.Reset()
				if err := s.Short.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"short\"")
			}
		case "fur":
			if err := func() error {
				s.Fur.Reset()
				if err := s.Fur.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fur\"")
			}
		case "egais_20":
			if err := func() error {
				s.Egais20.Reset()
				if err := s.Egais20.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egais_20\"")
			}
		case "egais_30":
			if err := func() error {
				s.Egais30.Reset()
				if err := s.Egais30.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"egais_30\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MarkCodeInfo")
	}

	return nil
}

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

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

// Encode encodes MarkMode as json.
func (s MarkMode) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes MarkMode from json.
func (s *MarkMode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MarkMode to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = MarkMode(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *MarkQuantity) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("numerator")
		e.Int(s.Numerator)
	}
	{
		e.FieldStart("denominator")
		e.Int(s.Denominator)
	}
}

var jsonFieldsNameOfMarkQuantity = [2]string{
	0: "numerator",
	1: "denominator",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "numerator":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Numerator = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"numerator\"")
			}
		case "denominator":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Int()
				s.Denominator = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"denominator\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MarkQuantity")
	}
	// 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(jsonFieldsNameOfMarkQuantity) {
					name = jsonFieldsNameOfMarkQuantity[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 *MarkQuantity) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *Me) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		e.Str(s.AccountID)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		e.FieldStart("test")
		e.Bool(s.Test)
	}
	{
		if s.Fiscalization.Set {
			e.FieldStart("fiscalization")
			s.Fiscalization.Encode(e)
		}
	}
	{
		if s.FiscalizationEnabled.Set {
			e.FieldStart("fiscalization_enabled")
			s.FiscalizationEnabled.Encode(e)
		}
	}
	{
		if s.PaymentMethods != nil {
			e.FieldStart("payment_methods")
			e.ArrStart()
			for _, elem := range s.PaymentMethods {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Itn.Set {
			e.FieldStart("itn")
			s.Itn.Encode(e)
		}
	}
	{
		if s.PayoutMethods != nil {
			e.FieldStart("payout_methods")
			e.ArrStart()
			for _, elem := range s.PayoutMethods {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
	{
		if s.PayoutBalance.Set {
			e.FieldStart("payout_balance")
			s.PayoutBalance.Encode(e)
		}
	}
}

var jsonFieldsNameOfMe = [10]string{
	0: "account_id",
	1: "status",
	2: "test",
	3: "fiscalization",
	4: "fiscalization_enabled",
	5: "payment_methods",
	6: "itn",
	7: "payout_methods",
	8: "name",
	9: "payout_balance",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.AccountID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "test":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Test = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		case "fiscalization":
			if err := func() error {
				s.Fiscalization.Reset()
				if err := s.Fiscalization.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscalization\"")
			}
		case "fiscalization_enabled":
			if err := func() error {
				s.FiscalizationEnabled.Reset()
				if err := s.FiscalizationEnabled.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscalization_enabled\"")
			}
		case "payment_methods":
			if err := func() error {
				s.PaymentMethods = make([]PaymentMethodType, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem PaymentMethodType
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.PaymentMethods = append(s.PaymentMethods, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_methods\"")
			}
		case "itn":
			if err := func() error {
				s.Itn.Reset()
				if err := s.Itn.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"itn\"")
			}
		case "payout_methods":
			if err := func() error {
				s.PayoutMethods = make([]PayoutMethodType, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem PayoutMethodType
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.PayoutMethods = append(s.PayoutMethods, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_methods\"")
			}
		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 "payout_balance":
			if err := func() error {
				s.PayoutBalance.Reset()
				if err := s.PayoutBalance.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_balance\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Me")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00000111,
		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(jsonFieldsNameOfMe) {
					name = jsonFieldsNameOfMe[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 *Me) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *MePayoutBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfMePayoutBalance = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode MePayoutBalance")
	}
	// 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(jsonFieldsNameOfMePayoutBalance) {
					name = jsonFieldsNameOfMePayoutBalance[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 *MePayoutBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes MeStatus as json.
func (s MeStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes MeStatus from json.
func (s *MeStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MeStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch MeStatus(v) {
	case MeStatusEnabled:
		*s = MeStatusEnabled
	case MeStatusDisabled:
		*s = MeStatusDisabled
	default:
		*s = MeStatus(v)
	}

	return nil
}

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

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

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

// encodeFields implements json.Marshaler.
func (s Metadata) encodeFields(e *jx.Encoder) {
	for k, elem := range s {
		e.FieldStart(k)

		elem.Encode(e)
	}
}

// Decode decodes Metadata from json.
func (s *Metadata) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Metadata to nil")
	}
	m := s.init()
	var propertiesCount int
	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		propertiesCount++
		var elem NilString
		if err := func() error {
			if err := elem.Decode(d); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			return errors.Wrapf(err, "decode field %q", k)
		}
		m[string(k)] = elem
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Metadata")
	}
	// Validate properties count.
	if err := (validate.Object{
		MinProperties:    0,
		MinPropertiesSet: false,
		MaxProperties:    16,
		MaxPropertiesSet: true,
	}).ValidateProperties(propertiesCount); err != nil {
		return errors.Wrap(err, "object")
	}

	return nil
}

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

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

// Encode encodes MiddleName as json.
func (s MiddleName) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes MiddleName from json.
func (s *MiddleName) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode MiddleName to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = MiddleName(unwrapped)
	return nil
}

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

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

// Encode encodes NextCursor as json.
func (s NextCursor) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes NextCursor from json.
func (s *NextCursor) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode NextCursor to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = NextCursor(unwrapped)
	return nil
}

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

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

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

// Decode decodes string from json.
func (o *NilString) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode NilString to nil")
	}
	if d.Next() == jx.Null {
		if err := d.Null(); err != nil {
			return err
		}

		var v string
		o.Value = v
		o.Null = true
		return nil
	}
	o.Null = false
	v, err := d.Str()
	if err != nil {
		return err
	}
	o.Value = string(v)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *NotFound) encodeFields(e *jx.Encoder) {
	{
		if s.Type.Set {
			e.FieldStart("type")
			s.Type.Encode(e)
		}
	}
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Parameter.Set {
			e.FieldStart("parameter")
			s.Parameter.Encode(e)
		}
	}
	{
		if s.RetryAfter.Set {
			e.FieldStart("retry_after")
			s.RetryAfter.Encode(e)
		}
	}
	{
		if s.Code.Set {
			e.FieldStart("code")
			s.Code.Encode(e)
		}
	}
}

var jsonFieldsNameOfNotFound = [6]string{
	0: "type",
	1: "id",
	2: "description",
	3: "parameter",
	4: "retry_after",
	5: "code",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			if err := func() error {
				s.Type.Reset()
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "parameter":
			if err := func() error {
				s.Parameter.Reset()
				if err := s.Parameter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"parameter\"")
			}
		case "retry_after":
			if err := func() error {
				s.RetryAfter.Reset()
				if err := s.RetryAfter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"retry_after\"")
			}
		case "code":
			if err := func() error {
				s.Code.Reset()
				if err := s.Code.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode NotFound")
	}

	return nil
}

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

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

// Encode encodes NotFoundCode as json.
func (s NotFoundCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes NotFoundCode from json.
func (s *NotFoundCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode NotFoundCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch NotFoundCode(v) {
	case NotFoundCodeNotFound:
		*s = NotFoundCodeNotFound
	default:
		*s = NotFoundCode(v)
	}

	return nil
}

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

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

// Encode encodes NotFoundType as json.
func (s NotFoundType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes NotFoundType from json.
func (s *NotFoundType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode NotFoundType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch NotFoundType(v) {
	case NotFoundTypeError:
		*s = NotFoundTypeError
	default:
		*s = NotFoundType(v)
	}

	return nil
}

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

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

// Encode encodes NpdIncomeReceiptId as json.
func (s NpdIncomeReceiptId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes NpdIncomeReceiptId from json.
func (s *NpdIncomeReceiptId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode NpdIncomeReceiptId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = NpdIncomeReceiptId(unwrapped)
	return nil
}

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

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

// Encode encodes Oktmo as json.
func (s Oktmo) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes Oktmo from json.
func (s *Oktmo) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Oktmo to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Oktmo(unwrapped)
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBankCardProduct) 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 Capture as json.
func (o OptCapture) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

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

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

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

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

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

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

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

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

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

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

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptClientIp) 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 ElectronicCertificateArticleCode as json.
func (o OptElectronicCertificateArticleCode) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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 int32 as json.
func (o OptInt32) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	e.Int32(int32(o.Value))
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Decode decodes Metadata from json.
func (o *OptMetadata) Decode(d *jx.Decoder) error {
	if o == nil {
		return errors.New("invalid: unable to decode OptMetadata to nil")
	}
	o.Set = true
	o.Value = make(Metadata)
	if err := o.Value.Decode(d); err != nil {
		return err
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptSbpPayerBankDetails) 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 encodes TaxSystemCode as json.
func (o OptTaxSystemCode) Encode(e *jx.Encoder) {
	if !o.Set {
		return
	}
	o.Value.Encode(e)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// encodeFields encodes fields.
func (s *Payment) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.IncomeAmount.Set {
			e.FieldStart("income_amount")
			s.IncomeAmount.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		e.FieldStart("recipient")
		s.Recipient.Encode(e)
	}
	{
		if s.PaymentMethod.Set {
			e.FieldStart("payment_method")
			s.PaymentMethod.Encode(e)
		}
	}
	{
		if s.CapturedAt.Set {
			e.FieldStart("captured_at")
			s.CapturedAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
	{
		if s.ExpiresAt.Set {
			e.FieldStart("expires_at")
			s.ExpiresAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Confirmation.Set {
			e.FieldStart("confirmation")
			s.Confirmation.Encode(e)
		}
	}
	{
		e.FieldStart("test")
		s.Test.Encode(e)
	}
	{
		if s.RefundedAmount.Set {
			e.FieldStart("refunded_amount")
			s.RefundedAmount.Encode(e)
		}
	}
	{
		e.FieldStart("paid")
		e.Bool(s.Paid)
	}
	{
		e.FieldStart("refundable")
		e.Bool(s.Refundable)
	}
	{
		if s.ReceiptRegistration.Set {
			e.FieldStart("receipt_registration")
			s.ReceiptRegistration.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		if s.CancellationDetails.Set {
			e.FieldStart("cancellation_details")
			s.CancellationDetails.Encode(e)
		}
	}
	{
		if s.AuthorizationDetails.Set {
			e.FieldStart("authorization_details")
			s.AuthorizationDetails.Encode(e)
		}
	}
	{
		if s.Transfers != nil {
			e.FieldStart("transfers")
			e.ArrStart()
			for _, elem := range s.Transfers {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.MerchantCustomerID.Set {
			e.FieldStart("merchant_customer_id")
			s.MerchantCustomerID.Encode(e)
		}
	}
	{
		if s.InvoiceDetails.Set {
			e.FieldStart("invoice_details")
			s.InvoiceDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfPayment = [23]string{
	0:  "id",
	1:  "status",
	2:  "amount",
	3:  "income_amount",
	4:  "description",
	5:  "recipient",
	6:  "payment_method",
	7:  "captured_at",
	8:  "created_at",
	9:  "expires_at",
	10: "confirmation",
	11: "test",
	12: "refunded_amount",
	13: "paid",
	14: "refundable",
	15: "receipt_registration",
	16: "metadata",
	17: "cancellation_details",
	18: "authorization_details",
	19: "transfers",
	20: "deal",
	21: "merchant_customer_id",
	22: "invoice_details",
}

// Decode decodes Payment from json.
func (s *Payment) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Payment 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "income_amount":
			if err := func() error {
				s.IncomeAmount.Reset()
				if err := s.IncomeAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"income_amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "recipient":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				if err := s.Recipient.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"recipient\"")
			}
		case "payment_method":
			if err := func() error {
				s.PaymentMethod.Reset()
				if err := s.PaymentMethod.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_method\"")
			}
		case "captured_at":
			if err := func() error {
				s.CapturedAt.Reset()
				if err := s.CapturedAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"captured_at\"")
			}
		case "created_at":
			requiredBitSet[1] |= 1 << 0
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "expires_at":
			if err := func() error {
				s.ExpiresAt.Reset()
				if err := s.ExpiresAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expires_at\"")
			}
		case "confirmation":
			if err := func() error {
				s.Confirmation.Reset()
				if err := s.Confirmation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation\"")
			}
		case "test":
			requiredBitSet[1] |= 1 << 3
			if err := func() error {
				if err := s.Test.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		case "refunded_amount":
			if err := func() error {
				s.RefundedAmount.Reset()
				if err := s.RefundedAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refunded_amount\"")
			}
		case "paid":
			requiredBitSet[1] |= 1 << 5
			if err := func() error {
				v, err := d.Bool()
				s.Paid = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"paid\"")
			}
		case "refundable":
			requiredBitSet[1] |= 1 << 6
			if err := func() error {
				v, err := d.Bool()
				s.Refundable = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refundable\"")
			}
		case "receipt_registration":
			if err := func() error {
				s.ReceiptRegistration.Reset()
				if err := s.ReceiptRegistration.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_registration\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "cancellation_details":
			if err := func() error {
				s.CancellationDetails.Reset()
				if err := s.CancellationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cancellation_details\"")
			}
		case "authorization_details":
			if err := func() error {
				s.AuthorizationDetails.Reset()
				if err := s.AuthorizationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"authorization_details\"")
			}
		case "transfers":
			if err := func() error {
				s.Transfers = make([]Transfer, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Transfer
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Transfers = append(s.Transfers, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"transfers\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "merchant_customer_id":
			if err := func() error {
				s.MerchantCustomerID.Reset()
				if err := s.MerchantCustomerID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"merchant_customer_id\"")
			}
		case "invoice_details":
			if err := func() error {
				s.InvoiceDetails.Reset()
				if err := s.InvoiceDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"invoice_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Payment")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00100111,
		0b01101001,
		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(jsonFieldsNameOfPayment) {
					name = jsonFieldsNameOfPayment[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 *Payment) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *PaymentAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentAmount")
	}
	// 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(jsonFieldsNameOfPaymentAmount) {
					name = jsonFieldsNameOfPaymentAmount[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 *PaymentAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *PaymentCancellationDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("party")
		s.Party.Encode(e)
	}
	{
		e.FieldStart("reason")
		s.Reason.Encode(e)
	}
}

var jsonFieldsNameOfPaymentCancellationDetails = [2]string{
	0: "party",
	1: "reason",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "party":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Party.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"party\"")
			}
		case "reason":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Reason.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"reason\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentCancellationDetails")
	}
	// 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(jsonFieldsNameOfPaymentCancellationDetails) {
					name = jsonFieldsNameOfPaymentCancellationDetails[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 *PaymentCancellationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentCancellationDetailsParty as json.
func (s PaymentCancellationDetailsParty) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentCancellationDetailsParty from json.
func (s *PaymentCancellationDetailsParty) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentCancellationDetailsParty to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentCancellationDetailsParty(v) {
	case PaymentCancellationDetailsPartyYooMoney:
		*s = PaymentCancellationDetailsPartyYooMoney
	case PaymentCancellationDetailsPartyPaymentNetwork:
		*s = PaymentCancellationDetailsPartyPaymentNetwork
	case PaymentCancellationDetailsPartyMerchant:
		*s = PaymentCancellationDetailsPartyMerchant
	default:
		*s = PaymentCancellationDetailsParty(v)
	}

	return nil
}

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

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

// Encode encodes PaymentCancellationDetailsReason as json.
func (s PaymentCancellationDetailsReason) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentCancellationDetailsReason from json.
func (s *PaymentCancellationDetailsReason) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentCancellationDetailsReason to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentCancellationDetailsReason(v) {
	case PaymentCancellationDetailsReason3dSecureFailed:
		*s = PaymentCancellationDetailsReason3dSecureFailed
	case PaymentCancellationDetailsReasonCallIssuer:
		*s = PaymentCancellationDetailsReasonCallIssuer
	case PaymentCancellationDetailsReasonCardExpired:
		*s = PaymentCancellationDetailsReasonCardExpired
	case PaymentCancellationDetailsReasonPaymentMethodLimitExceeded:
		*s = PaymentCancellationDetailsReasonPaymentMethodLimitExceeded
	case PaymentCancellationDetailsReasonPaymentMethodRestricted:
		*s = PaymentCancellationDetailsReasonPaymentMethodRestricted
	case PaymentCancellationDetailsReasonCountryForbidden:
		*s = PaymentCancellationDetailsReasonCountryForbidden
	case PaymentCancellationDetailsReasonGeneralDecline:
		*s = PaymentCancellationDetailsReasonGeneralDecline
	case PaymentCancellationDetailsReasonFraudSuspected:
		*s = PaymentCancellationDetailsReasonFraudSuspected
	case PaymentCancellationDetailsReasonIdentificationRequired:
		*s = PaymentCancellationDetailsReasonIdentificationRequired
	case PaymentCancellationDetailsReasonInsufficientFunds:
		*s = PaymentCancellationDetailsReasonInsufficientFunds
	case PaymentCancellationDetailsReasonInvalidCardNumber:
		*s = PaymentCancellationDetailsReasonInvalidCardNumber
	case PaymentCancellationDetailsReasonInvalidCsc:
		*s = PaymentCancellationDetailsReasonInvalidCsc
	case PaymentCancellationDetailsReasonIssuerUnavailable:
		*s = PaymentCancellationDetailsReasonIssuerUnavailable
	case PaymentCancellationDetailsReasonCanceledByMerchant:
		*s = PaymentCancellationDetailsReasonCanceledByMerchant
	case PaymentCancellationDetailsReasonPermissionRevoked:
		*s = PaymentCancellationDetailsReasonPermissionRevoked
	case PaymentCancellationDetailsReasonInternalTimeout:
		*s = PaymentCancellationDetailsReasonInternalTimeout
	case PaymentCancellationDetailsReasonExpiredOnConfirmation:
		*s = PaymentCancellationDetailsReasonExpiredOnConfirmation
	case PaymentCancellationDetailsReasonExpiredOnCapture:
		*s = PaymentCancellationDetailsReasonExpiredOnCapture
	case PaymentCancellationDetailsReasonUnsupportedMobileOperator:
		*s = PaymentCancellationDetailsReasonUnsupportedMobileOperator
	case PaymentCancellationDetailsReasonDealExpired:
		*s = PaymentCancellationDetailsReasonDealExpired
	default:
		*s = PaymentCancellationDetailsReason(v)
	}

	return nil
}

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

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

// Encode encodes PaymentConfirmation as json.
func (s PaymentConfirmation) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentConfirmation) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case ConfirmationRedirectPaymentConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationRedirect")
		{
			s := s.ConfirmationRedirect
			{
				if s.Enforce.Set {
					e.FieldStart("enforce")
					s.Enforce.Encode(e)
				}
			}
			{
				if s.ReturnURL.Set {
					e.FieldStart("return_url")
					s.ReturnURL.Encode(e)
				}
			}
			{
				e.FieldStart("confirmation_url")
				s.ConfirmationURL.Encode(e)
			}
		}
	case ConfirmationPaymentConfirmation:
		e.FieldStart("type")
		e.Str("Confirmation")
	case ConfirmationQrPaymentConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationQr")
		{
			s := s.ConfirmationQr
			{
				e.FieldStart("confirmation_data")
				e.Str(s.ConfirmationData)
			}
		}
	case ConfirmationEmbeddedPaymentConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationEmbedded")
		{
			s := s.ConfirmationEmbedded
			{
				e.FieldStart("confirmation_token")
				e.Str(s.ConfirmationToken)
			}
		}
	case ConfirmationMobileApplicationPaymentConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationMobileApplication")
		{
			s := s.ConfirmationMobileApplication
			{
				e.FieldStart("confirmation_url")
				e.Str(s.ConfirmationURL)
			}
		}
	}
}

// Decode decodes PaymentConfirmation from json.
func (s *PaymentConfirmation) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentConfirmation to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "ConfirmationRedirect":
					s.Type = ConfirmationRedirectPaymentConfirmation
					found = true
				case "Confirmation":
					s.Type = ConfirmationPaymentConfirmation
					found = true
				case "ConfirmationQr":
					s.Type = ConfirmationQrPaymentConfirmation
					found = true
				case "ConfirmationEmbedded":
					s.Type = ConfirmationEmbeddedPaymentConfirmation
					found = true
				case "ConfirmationMobileApplication":
					s.Type = ConfirmationMobileApplicationPaymentConfirmation
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case ConfirmationRedirectPaymentConfirmation:
		if err := s.ConfirmationRedirect.Decode(d); err != nil {
			return err
		}
	case ConfirmationPaymentConfirmation:
		if err := s.Confirmation.Decode(d); err != nil {
			return err
		}
	case ConfirmationQrPaymentConfirmation:
		if err := s.ConfirmationQr.Decode(d); err != nil {
			return err
		}
	case ConfirmationEmbeddedPaymentConfirmation:
		if err := s.ConfirmationEmbedded.Decode(d); err != nil {
			return err
		}
	case ConfirmationMobileApplicationPaymentConfirmation:
		if err := s.ConfirmationMobileApplication.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentDeal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("settlements")
		s.Settlements.Encode(e)
	}
}

var jsonFieldsNameOfPaymentDeal = [2]string{
	0: "id",
	1: "settlements",
}

// Decode decodes PaymentDeal from json.
func (s *PaymentDeal) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentDeal 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "settlements":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Settlements.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"settlements\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentDeal")
	}
	// 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(jsonFieldsNameOfPaymentDeal) {
					name = jsonFieldsNameOfPaymentDeal[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 *PaymentDeal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentId as json.
func (s PaymentId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PaymentId from json.
func (s *PaymentId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentId(unwrapped)
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentIncomeAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentIncomeAmount = [2]string{
	0: "value",
	1: "currency",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentIncomeAmount")
	}
	// 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(jsonFieldsNameOfPaymentIncomeAmount) {
					name = jsonFieldsNameOfPaymentIncomeAmount[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 *PaymentIncomeAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

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

// encodeFields encodes fields.
func (s *PaymentInvoiceDetails) encodeFields(e *jx.Encoder) {
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentInvoiceDetails = [1]string{
	0: "id",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentInvoiceDetails")
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentList) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.NextCursor.Set {
			e.FieldStart("next_cursor")
			s.NextCursor.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentList = [3]string{
	0: "type",
	1: "items",
	2: "next_cursor",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]Payment, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Payment
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "next_cursor":
			if err := func() error {
				s.NextCursor.Reset()
				if err := s.NextCursor.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next_cursor\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentList")
	}
	// 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(jsonFieldsNameOfPaymentList) {
					name = jsonFieldsNameOfPaymentList[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 *PaymentList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentListType as json.
func (s PaymentListType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentListType from json.
func (s *PaymentListType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentListType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentListType(v) {
	case PaymentListTypeList:
		*s = PaymentListTypeList
	default:
		*s = PaymentListType(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodAlfabank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Login.Set {
			e.FieldStart("login")
			s.Login.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodAlfabank = [6]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "login",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "login":
			if err := func() error {
				s.Login.Reset()
				if err := s.Login.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"login\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodAlfabank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodAlfabank) {
					name = jsonFieldsNameOfPaymentMethodAlfabank[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 *PaymentMethodAlfabank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodAlfabankStatus as json.
func (s PaymentMethodAlfabankStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodAlfabankStatus from json.
func (s *PaymentMethodAlfabankStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodAlfabankStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodAlfabankStatus(v) {
	case PaymentMethodAlfabankStatusPending:
		*s = PaymentMethodAlfabankStatusPending
	case PaymentMethodAlfabankStatusActive:
		*s = PaymentMethodAlfabankStatusActive
	case PaymentMethodAlfabankStatusInactive:
		*s = PaymentMethodAlfabankStatusInactive
	default:
		*s = PaymentMethodAlfabankStatus(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodApplePay) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodApplePay = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodApplePay")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodApplePay) {
					name = jsonFieldsNameOfPaymentMethodApplePay[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 *PaymentMethodApplePay) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodApplePayStatus as json.
func (s PaymentMethodApplePayStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodApplePayStatus from json.
func (s *PaymentMethodApplePayStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodApplePayStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodApplePayStatus(v) {
	case PaymentMethodApplePayStatusPending:
		*s = PaymentMethodApplePayStatusPending
	case PaymentMethodApplePayStatusActive:
		*s = PaymentMethodApplePayStatusActive
	case PaymentMethodApplePayStatusInactive:
		*s = PaymentMethodApplePayStatusInactive
	default:
		*s = PaymentMethodApplePayStatus(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodB2bSberbank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		e.FieldStart("payment_purpose")
		s.PaymentPurpose.Encode(e)
	}
	{
		e.FieldStart("vat_data")
		s.VatData.Encode(e)
	}
	{
		if s.PayerBankDetails.Set {
			e.FieldStart("payer_bank_details")
			s.PayerBankDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodB2bSberbank = [8]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "payment_purpose",
	6: "vat_data",
	7: "payer_bank_details",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "payment_purpose":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				if err := s.PaymentPurpose.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_purpose\"")
			}
		case "vat_data":
			requiredBitSet[0] |= 1 << 6
			if err := func() error {
				if err := s.VatData.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"vat_data\"")
			}
		case "payer_bank_details":
			if err := func() error {
				s.PayerBankDetails.Reset()
				if err := s.PayerBankDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payer_bank_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodB2bSberbank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b01101111,
	} {
		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(jsonFieldsNameOfPaymentMethodB2bSberbank) {
					name = jsonFieldsNameOfPaymentMethodB2bSberbank[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 *PaymentMethodB2bSberbank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodB2bSberbankStatus as json.
func (s PaymentMethodB2bSberbankStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodB2bSberbankStatus from json.
func (s *PaymentMethodB2bSberbankStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodB2bSberbankStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodB2bSberbankStatus(v) {
	case PaymentMethodB2bSberbankStatusPending:
		*s = PaymentMethodB2bSberbankStatusPending
	case PaymentMethodB2bSberbankStatusActive:
		*s = PaymentMethodB2bSberbankStatusActive
	case PaymentMethodB2bSberbankStatusInactive:
		*s = PaymentMethodB2bSberbankStatusInactive
	default:
		*s = PaymentMethodB2bSberbankStatus(v)
	}

	return nil
}

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

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

// Encode encodes PaymentMethodB2bSberbankVatData as json.
func (s PaymentMethodB2bSberbankVatData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentMethodB2bSberbankVatData) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankCalculatedVatData")
		{
			s := s.B2bSberbankCalculatedVatData
			{
				e.FieldStart("rate")
				s.Rate.Encode(e)
			}
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	case B2bSberbankUntaxedVatDataPaymentMethodB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankUntaxedVatData")
	case B2bSberbankMixedVatDataPaymentMethodB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankMixedVatData")
		{
			s := s.B2bSberbankMixedVatData
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	}
}

// Decode decodes PaymentMethodB2bSberbankVatData from json.
func (s *PaymentMethodB2bSberbankVatData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodB2bSberbankVatData to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "B2bSberbankCalculatedVatData":
					s.Type = B2bSberbankCalculatedVatDataPaymentMethodB2bSberbankVatData
					found = true
				case "B2bSberbankUntaxedVatData":
					s.Type = B2bSberbankUntaxedVatDataPaymentMethodB2bSberbankVatData
					found = true
				case "B2bSberbankMixedVatData":
					s.Type = B2bSberbankMixedVatDataPaymentMethodB2bSberbankVatData
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankCalculatedVatData.Decode(d); err != nil {
			return err
		}
	case B2bSberbankUntaxedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankUntaxedVatData.Decode(d); err != nil {
			return err
		}
	case B2bSberbankMixedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankMixedVatData.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodBankCard) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodBankCard = [6]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "card",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodBankCard")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodBankCard) {
					name = jsonFieldsNameOfPaymentMethodBankCard[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 *PaymentMethodBankCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodBankCardStatus as json.
func (s PaymentMethodBankCardStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodBankCardStatus from json.
func (s *PaymentMethodBankCardStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodBankCardStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodBankCardStatus(v) {
	case PaymentMethodBankCardStatusPending:
		*s = PaymentMethodBankCardStatusPending
	case PaymentMethodBankCardStatusActive:
		*s = PaymentMethodBankCardStatusActive
	case PaymentMethodBankCardStatusInactive:
		*s = PaymentMethodBankCardStatusInactive
	default:
		*s = PaymentMethodBankCardStatus(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodCash) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodCash = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodCash")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodCash) {
					name = jsonFieldsNameOfPaymentMethodCash[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 *PaymentMethodCash) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodCashStatus as json.
func (s PaymentMethodCashStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodCashStatus from json.
func (s *PaymentMethodCashStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodCashStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodCashStatus(v) {
	case PaymentMethodCashStatusPending:
		*s = PaymentMethodCashStatusPending
	case PaymentMethodCashStatusActive:
		*s = PaymentMethodCashStatusActive
	case PaymentMethodCashStatusInactive:
		*s = PaymentMethodCashStatusInactive
	default:
		*s = PaymentMethodCashStatus(v)
	}

	return nil
}

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

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

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

// encodeFields encodes fields.
func (s *PaymentMethodDataB2bSberbank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("payment_purpose")
		s.PaymentPurpose.Encode(e)
	}
	{
		e.FieldStart("vat_data")
		s.VatData.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodDataB2bSberbank = [3]string{
	0: "type",
	1: "payment_purpose",
	2: "vat_data",
}

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

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "payment_purpose":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.PaymentPurpose.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_purpose\"")
			}
		case "vat_data":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.VatData.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"vat_data\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataB2bSberbank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfPaymentMethodDataB2bSberbank) {
					name = jsonFieldsNameOfPaymentMethodDataB2bSberbank[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 *PaymentMethodDataB2bSberbank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

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

// Encode encodes PaymentMethodDataB2bSberbankType as json.
func (s PaymentMethodDataB2bSberbankType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataB2bSberbankType from json.
func (s *PaymentMethodDataB2bSberbankType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataB2bSberbankType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataB2bSberbankType(v) {
	case PaymentMethodDataB2bSberbankTypeBankCard:
		*s = PaymentMethodDataB2bSberbankTypeBankCard
	case PaymentMethodDataB2bSberbankTypeCash:
		*s = PaymentMethodDataB2bSberbankTypeCash
	case PaymentMethodDataB2bSberbankTypeSberbank:
		*s = PaymentMethodDataB2bSberbankTypeSberbank
	case PaymentMethodDataB2bSberbankTypeTinkoffBank:
		*s = PaymentMethodDataB2bSberbankTypeTinkoffBank
	case PaymentMethodDataB2bSberbankTypeYooMoney:
		*s = PaymentMethodDataB2bSberbankTypeYooMoney
	case PaymentMethodDataB2bSberbankTypeMobileBalance:
		*s = PaymentMethodDataB2bSberbankTypeMobileBalance
	case PaymentMethodDataB2bSberbankTypeB2bSberbank:
		*s = PaymentMethodDataB2bSberbankTypeB2bSberbank
	case PaymentMethodDataB2bSberbankTypeSbp:
		*s = PaymentMethodDataB2bSberbankTypeSbp
	case PaymentMethodDataB2bSberbankTypeSberLoan:
		*s = PaymentMethodDataB2bSberbankTypeSberLoan
	case PaymentMethodDataB2bSberbankTypeElectronicCertificate:
		*s = PaymentMethodDataB2bSberbankTypeElectronicCertificate
	case PaymentMethodDataB2bSberbankTypeSberBnpl:
		*s = PaymentMethodDataB2bSberbankTypeSberBnpl
	default:
		*s = PaymentMethodDataB2bSberbankType(v)
	}

	return nil
}

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

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

// Encode encodes PaymentMethodDataB2bSberbankVatData as json.
func (s PaymentMethodDataB2bSberbankVatData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentMethodDataB2bSberbankVatData) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodDataB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankCalculatedVatData")
		{
			s := s.B2bSberbankCalculatedVatData
			{
				e.FieldStart("rate")
				s.Rate.Encode(e)
			}
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	case B2bSberbankUntaxedVatDataPaymentMethodDataB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankUntaxedVatData")
	case B2bSberbankMixedVatDataPaymentMethodDataB2bSberbankVatData:
		e.FieldStart("type")
		e.Str("B2bSberbankMixedVatData")
		{
			s := s.B2bSberbankMixedVatData
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	}
}

// Decode decodes PaymentMethodDataB2bSberbankVatData from json.
func (s *PaymentMethodDataB2bSberbankVatData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataB2bSberbankVatData to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "B2bSberbankCalculatedVatData":
					s.Type = B2bSberbankCalculatedVatDataPaymentMethodDataB2bSberbankVatData
					found = true
				case "B2bSberbankUntaxedVatData":
					s.Type = B2bSberbankUntaxedVatDataPaymentMethodDataB2bSberbankVatData
					found = true
				case "B2bSberbankMixedVatData":
					s.Type = B2bSberbankMixedVatDataPaymentMethodDataB2bSberbankVatData
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankCalculatedVatData.Decode(d); err != nil {
			return err
		}
	case B2bSberbankUntaxedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankUntaxedVatData.Decode(d); err != nil {
			return err
		}
	case B2bSberbankMixedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankMixedVatData.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

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

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataB2bSberbankVatData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataBankCard) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataBankCard) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodDataBankCard = [2]string{
	0: "type",
	1: "card",
}

// Decode decodes PaymentMethodDataBankCard from json.
func (s *PaymentMethodDataBankCard) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataBankCard to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataBankCard")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataBankCard) {
					name = jsonFieldsNameOfPaymentMethodDataBankCard[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 *PaymentMethodDataBankCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataBankCard) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataBankCardType as json.
func (s PaymentMethodDataBankCardType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataBankCardType from json.
func (s *PaymentMethodDataBankCardType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataBankCardType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataBankCardType(v) {
	case PaymentMethodDataBankCardTypeBankCard:
		*s = PaymentMethodDataBankCardTypeBankCard
	case PaymentMethodDataBankCardTypeCash:
		*s = PaymentMethodDataBankCardTypeCash
	case PaymentMethodDataBankCardTypeSberbank:
		*s = PaymentMethodDataBankCardTypeSberbank
	case PaymentMethodDataBankCardTypeTinkoffBank:
		*s = PaymentMethodDataBankCardTypeTinkoffBank
	case PaymentMethodDataBankCardTypeYooMoney:
		*s = PaymentMethodDataBankCardTypeYooMoney
	case PaymentMethodDataBankCardTypeMobileBalance:
		*s = PaymentMethodDataBankCardTypeMobileBalance
	case PaymentMethodDataBankCardTypeB2bSberbank:
		*s = PaymentMethodDataBankCardTypeB2bSberbank
	case PaymentMethodDataBankCardTypeSbp:
		*s = PaymentMethodDataBankCardTypeSbp
	case PaymentMethodDataBankCardTypeSberLoan:
		*s = PaymentMethodDataBankCardTypeSberLoan
	case PaymentMethodDataBankCardTypeElectronicCertificate:
		*s = PaymentMethodDataBankCardTypeElectronicCertificate
	case PaymentMethodDataBankCardTypeSberBnpl:
		*s = PaymentMethodDataBankCardTypeSberBnpl
	default:
		*s = PaymentMethodDataBankCardType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataBankCardType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataBankCardType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataCash) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataCash) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodDataCash = [2]string{
	0: "type",
	1: "phone",
}

// Decode decodes PaymentMethodDataCash from json.
func (s *PaymentMethodDataCash) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataCash to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataCash")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataCash) {
					name = jsonFieldsNameOfPaymentMethodDataCash[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 *PaymentMethodDataCash) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataCash) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataCashType as json.
func (s PaymentMethodDataCashType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataCashType from json.
func (s *PaymentMethodDataCashType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataCashType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataCashType(v) {
	case PaymentMethodDataCashTypeBankCard:
		*s = PaymentMethodDataCashTypeBankCard
	case PaymentMethodDataCashTypeCash:
		*s = PaymentMethodDataCashTypeCash
	case PaymentMethodDataCashTypeSberbank:
		*s = PaymentMethodDataCashTypeSberbank
	case PaymentMethodDataCashTypeTinkoffBank:
		*s = PaymentMethodDataCashTypeTinkoffBank
	case PaymentMethodDataCashTypeYooMoney:
		*s = PaymentMethodDataCashTypeYooMoney
	case PaymentMethodDataCashTypeMobileBalance:
		*s = PaymentMethodDataCashTypeMobileBalance
	case PaymentMethodDataCashTypeB2bSberbank:
		*s = PaymentMethodDataCashTypeB2bSberbank
	case PaymentMethodDataCashTypeSbp:
		*s = PaymentMethodDataCashTypeSbp
	case PaymentMethodDataCashTypeSberLoan:
		*s = PaymentMethodDataCashTypeSberLoan
	case PaymentMethodDataCashTypeElectronicCertificate:
		*s = PaymentMethodDataCashTypeElectronicCertificate
	case PaymentMethodDataCashTypeSberBnpl:
		*s = PaymentMethodDataCashTypeSberBnpl
	default:
		*s = PaymentMethodDataCashType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataCashType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataCashType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataElectronicCertificate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataElectronicCertificate) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.ElectronicCertificate.Set {
			e.FieldStart("electronic_certificate")
			s.ElectronicCertificate.Encode(e)
		}
	}
	{
		if s.Articles != nil {
			e.FieldStart("articles")
			e.ArrStart()
			for _, elem := range s.Articles {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfPaymentMethodDataElectronicCertificate = [4]string{
	0: "type",
	1: "card",
	2: "electronic_certificate",
	3: "articles",
}

// Decode decodes PaymentMethodDataElectronicCertificate from json.
func (s *PaymentMethodDataElectronicCertificate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataElectronicCertificate to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		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 "electronic_certificate":
			if err := func() error {
				s.ElectronicCertificate.Reset()
				if err := s.ElectronicCertificate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"electronic_certificate\"")
			}
		case "articles":
			if err := func() error {
				s.Articles = make([]ElectronicCertificateArticle, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ElectronicCertificateArticle
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Articles = append(s.Articles, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"articles\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataElectronicCertificate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataElectronicCertificate) {
					name = jsonFieldsNameOfPaymentMethodDataElectronicCertificate[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 *PaymentMethodDataElectronicCertificate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataElectronicCertificate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataElectronicCertificateType as json.
func (s PaymentMethodDataElectronicCertificateType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataElectronicCertificateType from json.
func (s *PaymentMethodDataElectronicCertificateType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataElectronicCertificateType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataElectronicCertificateType(v) {
	case PaymentMethodDataElectronicCertificateTypeBankCard:
		*s = PaymentMethodDataElectronicCertificateTypeBankCard
	case PaymentMethodDataElectronicCertificateTypeCash:
		*s = PaymentMethodDataElectronicCertificateTypeCash
	case PaymentMethodDataElectronicCertificateTypeSberbank:
		*s = PaymentMethodDataElectronicCertificateTypeSberbank
	case PaymentMethodDataElectronicCertificateTypeTinkoffBank:
		*s = PaymentMethodDataElectronicCertificateTypeTinkoffBank
	case PaymentMethodDataElectronicCertificateTypeYooMoney:
		*s = PaymentMethodDataElectronicCertificateTypeYooMoney
	case PaymentMethodDataElectronicCertificateTypeMobileBalance:
		*s = PaymentMethodDataElectronicCertificateTypeMobileBalance
	case PaymentMethodDataElectronicCertificateTypeB2bSberbank:
		*s = PaymentMethodDataElectronicCertificateTypeB2bSberbank
	case PaymentMethodDataElectronicCertificateTypeSbp:
		*s = PaymentMethodDataElectronicCertificateTypeSbp
	case PaymentMethodDataElectronicCertificateTypeSberLoan:
		*s = PaymentMethodDataElectronicCertificateTypeSberLoan
	case PaymentMethodDataElectronicCertificateTypeElectronicCertificate:
		*s = PaymentMethodDataElectronicCertificateTypeElectronicCertificate
	case PaymentMethodDataElectronicCertificateTypeSberBnpl:
		*s = PaymentMethodDataElectronicCertificateTypeSberBnpl
	default:
		*s = PaymentMethodDataElectronicCertificateType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataElectronicCertificateType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataElectronicCertificateType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataMobileBalance) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataMobileBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("phone")
		e.Str(s.Phone)
	}
}

var jsonFieldsNameOfPaymentMethodDataMobileBalance = [2]string{
	0: "type",
	1: "phone",
}

// Decode decodes PaymentMethodDataMobileBalance from json.
func (s *PaymentMethodDataMobileBalance) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataMobileBalance to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Phone = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataMobileBalance")
	}
	// 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(jsonFieldsNameOfPaymentMethodDataMobileBalance) {
					name = jsonFieldsNameOfPaymentMethodDataMobileBalance[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 *PaymentMethodDataMobileBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataMobileBalance) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataMobileBalanceType as json.
func (s PaymentMethodDataMobileBalanceType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataMobileBalanceType from json.
func (s *PaymentMethodDataMobileBalanceType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataMobileBalanceType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataMobileBalanceType(v) {
	case PaymentMethodDataMobileBalanceTypeBankCard:
		*s = PaymentMethodDataMobileBalanceTypeBankCard
	case PaymentMethodDataMobileBalanceTypeCash:
		*s = PaymentMethodDataMobileBalanceTypeCash
	case PaymentMethodDataMobileBalanceTypeSberbank:
		*s = PaymentMethodDataMobileBalanceTypeSberbank
	case PaymentMethodDataMobileBalanceTypeTinkoffBank:
		*s = PaymentMethodDataMobileBalanceTypeTinkoffBank
	case PaymentMethodDataMobileBalanceTypeYooMoney:
		*s = PaymentMethodDataMobileBalanceTypeYooMoney
	case PaymentMethodDataMobileBalanceTypeMobileBalance:
		*s = PaymentMethodDataMobileBalanceTypeMobileBalance
	case PaymentMethodDataMobileBalanceTypeB2bSberbank:
		*s = PaymentMethodDataMobileBalanceTypeB2bSberbank
	case PaymentMethodDataMobileBalanceTypeSbp:
		*s = PaymentMethodDataMobileBalanceTypeSbp
	case PaymentMethodDataMobileBalanceTypeSberLoan:
		*s = PaymentMethodDataMobileBalanceTypeSberLoan
	case PaymentMethodDataMobileBalanceTypeElectronicCertificate:
		*s = PaymentMethodDataMobileBalanceTypeElectronicCertificate
	case PaymentMethodDataMobileBalanceTypeSberBnpl:
		*s = PaymentMethodDataMobileBalanceTypeSberBnpl
	default:
		*s = PaymentMethodDataMobileBalanceType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataMobileBalanceType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataMobileBalanceType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataSberBnpl) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataSberBnpl) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodDataSberBnpl = [2]string{
	0: "type",
	1: "phone",
}

// Decode decodes PaymentMethodDataSberBnpl from json.
func (s *PaymentMethodDataSberBnpl) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberBnpl to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataSberBnpl")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataSberBnpl) {
					name = jsonFieldsNameOfPaymentMethodDataSberBnpl[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 *PaymentMethodDataSberBnpl) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberBnpl) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataSberBnplType as json.
func (s PaymentMethodDataSberBnplType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataSberBnplType from json.
func (s *PaymentMethodDataSberBnplType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberBnplType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataSberBnplType(v) {
	case PaymentMethodDataSberBnplTypeBankCard:
		*s = PaymentMethodDataSberBnplTypeBankCard
	case PaymentMethodDataSberBnplTypeCash:
		*s = PaymentMethodDataSberBnplTypeCash
	case PaymentMethodDataSberBnplTypeSberbank:
		*s = PaymentMethodDataSberBnplTypeSberbank
	case PaymentMethodDataSberBnplTypeTinkoffBank:
		*s = PaymentMethodDataSberBnplTypeTinkoffBank
	case PaymentMethodDataSberBnplTypeYooMoney:
		*s = PaymentMethodDataSberBnplTypeYooMoney
	case PaymentMethodDataSberBnplTypeMobileBalance:
		*s = PaymentMethodDataSberBnplTypeMobileBalance
	case PaymentMethodDataSberBnplTypeB2bSberbank:
		*s = PaymentMethodDataSberBnplTypeB2bSberbank
	case PaymentMethodDataSberBnplTypeSbp:
		*s = PaymentMethodDataSberBnplTypeSbp
	case PaymentMethodDataSberBnplTypeSberLoan:
		*s = PaymentMethodDataSberBnplTypeSberLoan
	case PaymentMethodDataSberBnplTypeElectronicCertificate:
		*s = PaymentMethodDataSberBnplTypeElectronicCertificate
	case PaymentMethodDataSberBnplTypeSberBnpl:
		*s = PaymentMethodDataSberBnplTypeSberBnpl
	default:
		*s = PaymentMethodDataSberBnplType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataSberBnplType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberBnplType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataSberLoan) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataSberLoan) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodDataSberLoan = [1]string{
	0: "type",
}

// Decode decodes PaymentMethodDataSberLoan from json.
func (s *PaymentMethodDataSberLoan) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberLoan to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataSberLoan")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataSberLoan) {
					name = jsonFieldsNameOfPaymentMethodDataSberLoan[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 *PaymentMethodDataSberLoan) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberLoan) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataSberLoanType as json.
func (s PaymentMethodDataSberLoanType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataSberLoanType from json.
func (s *PaymentMethodDataSberLoanType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberLoanType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataSberLoanType(v) {
	case PaymentMethodDataSberLoanTypeBankCard:
		*s = PaymentMethodDataSberLoanTypeBankCard
	case PaymentMethodDataSberLoanTypeCash:
		*s = PaymentMethodDataSberLoanTypeCash
	case PaymentMethodDataSberLoanTypeSberbank:
		*s = PaymentMethodDataSberLoanTypeSberbank
	case PaymentMethodDataSberLoanTypeTinkoffBank:
		*s = PaymentMethodDataSberLoanTypeTinkoffBank
	case PaymentMethodDataSberLoanTypeYooMoney:
		*s = PaymentMethodDataSberLoanTypeYooMoney
	case PaymentMethodDataSberLoanTypeMobileBalance:
		*s = PaymentMethodDataSberLoanTypeMobileBalance
	case PaymentMethodDataSberLoanTypeB2bSberbank:
		*s = PaymentMethodDataSberLoanTypeB2bSberbank
	case PaymentMethodDataSberLoanTypeSbp:
		*s = PaymentMethodDataSberLoanTypeSbp
	case PaymentMethodDataSberLoanTypeSberLoan:
		*s = PaymentMethodDataSberLoanTypeSberLoan
	case PaymentMethodDataSberLoanTypeElectronicCertificate:
		*s = PaymentMethodDataSberLoanTypeElectronicCertificate
	case PaymentMethodDataSberLoanTypeSberBnpl:
		*s = PaymentMethodDataSberLoanTypeSberBnpl
	default:
		*s = PaymentMethodDataSberLoanType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataSberLoanType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberLoanType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataSberbank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataSberbank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodDataSberbank = [2]string{
	0: "type",
	1: "phone",
}

// Decode decodes PaymentMethodDataSberbank from json.
func (s *PaymentMethodDataSberbank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberbank to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataSberbank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataSberbank) {
					name = jsonFieldsNameOfPaymentMethodDataSberbank[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 *PaymentMethodDataSberbank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberbank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataSberbankType as json.
func (s PaymentMethodDataSberbankType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataSberbankType from json.
func (s *PaymentMethodDataSberbankType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSberbankType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataSberbankType(v) {
	case PaymentMethodDataSberbankTypeBankCard:
		*s = PaymentMethodDataSberbankTypeBankCard
	case PaymentMethodDataSberbankTypeCash:
		*s = PaymentMethodDataSberbankTypeCash
	case PaymentMethodDataSberbankTypeSberbank:
		*s = PaymentMethodDataSberbankTypeSberbank
	case PaymentMethodDataSberbankTypeTinkoffBank:
		*s = PaymentMethodDataSberbankTypeTinkoffBank
	case PaymentMethodDataSberbankTypeYooMoney:
		*s = PaymentMethodDataSberbankTypeYooMoney
	case PaymentMethodDataSberbankTypeMobileBalance:
		*s = PaymentMethodDataSberbankTypeMobileBalance
	case PaymentMethodDataSberbankTypeB2bSberbank:
		*s = PaymentMethodDataSberbankTypeB2bSberbank
	case PaymentMethodDataSberbankTypeSbp:
		*s = PaymentMethodDataSberbankTypeSbp
	case PaymentMethodDataSberbankTypeSberLoan:
		*s = PaymentMethodDataSberbankTypeSberLoan
	case PaymentMethodDataSberbankTypeElectronicCertificate:
		*s = PaymentMethodDataSberbankTypeElectronicCertificate
	case PaymentMethodDataSberbankTypeSberBnpl:
		*s = PaymentMethodDataSberbankTypeSberBnpl
	default:
		*s = PaymentMethodDataSberbankType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataSberbankType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSberbankType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataSbp) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataSbp) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodDataSbp = [1]string{
	0: "type",
}

// Decode decodes PaymentMethodDataSbp from json.
func (s *PaymentMethodDataSbp) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSbp to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataSbp")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataSbp) {
					name = jsonFieldsNameOfPaymentMethodDataSbp[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 *PaymentMethodDataSbp) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSbp) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataSbpType as json.
func (s PaymentMethodDataSbpType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataSbpType from json.
func (s *PaymentMethodDataSbpType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataSbpType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataSbpType(v) {
	case PaymentMethodDataSbpTypeBankCard:
		*s = PaymentMethodDataSbpTypeBankCard
	case PaymentMethodDataSbpTypeCash:
		*s = PaymentMethodDataSbpTypeCash
	case PaymentMethodDataSbpTypeSberbank:
		*s = PaymentMethodDataSbpTypeSberbank
	case PaymentMethodDataSbpTypeTinkoffBank:
		*s = PaymentMethodDataSbpTypeTinkoffBank
	case PaymentMethodDataSbpTypeYooMoney:
		*s = PaymentMethodDataSbpTypeYooMoney
	case PaymentMethodDataSbpTypeMobileBalance:
		*s = PaymentMethodDataSbpTypeMobileBalance
	case PaymentMethodDataSbpTypeB2bSberbank:
		*s = PaymentMethodDataSbpTypeB2bSberbank
	case PaymentMethodDataSbpTypeSbp:
		*s = PaymentMethodDataSbpTypeSbp
	case PaymentMethodDataSbpTypeSberLoan:
		*s = PaymentMethodDataSbpTypeSberLoan
	case PaymentMethodDataSbpTypeElectronicCertificate:
		*s = PaymentMethodDataSbpTypeElectronicCertificate
	case PaymentMethodDataSbpTypeSberBnpl:
		*s = PaymentMethodDataSbpTypeSberBnpl
	default:
		*s = PaymentMethodDataSbpType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataSbpType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataSbpType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataTinkoffBank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataTinkoffBank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodDataTinkoffBank = [1]string{
	0: "type",
}

// Decode decodes PaymentMethodDataTinkoffBank from json.
func (s *PaymentMethodDataTinkoffBank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataTinkoffBank to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataTinkoffBank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataTinkoffBank) {
					name = jsonFieldsNameOfPaymentMethodDataTinkoffBank[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 *PaymentMethodDataTinkoffBank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataTinkoffBank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataTinkoffBankType as json.
func (s PaymentMethodDataTinkoffBankType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataTinkoffBankType from json.
func (s *PaymentMethodDataTinkoffBankType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataTinkoffBankType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataTinkoffBankType(v) {
	case PaymentMethodDataTinkoffBankTypeBankCard:
		*s = PaymentMethodDataTinkoffBankTypeBankCard
	case PaymentMethodDataTinkoffBankTypeCash:
		*s = PaymentMethodDataTinkoffBankTypeCash
	case PaymentMethodDataTinkoffBankTypeSberbank:
		*s = PaymentMethodDataTinkoffBankTypeSberbank
	case PaymentMethodDataTinkoffBankTypeTinkoffBank:
		*s = PaymentMethodDataTinkoffBankTypeTinkoffBank
	case PaymentMethodDataTinkoffBankTypeYooMoney:
		*s = PaymentMethodDataTinkoffBankTypeYooMoney
	case PaymentMethodDataTinkoffBankTypeMobileBalance:
		*s = PaymentMethodDataTinkoffBankTypeMobileBalance
	case PaymentMethodDataTinkoffBankTypeB2bSberbank:
		*s = PaymentMethodDataTinkoffBankTypeB2bSberbank
	case PaymentMethodDataTinkoffBankTypeSbp:
		*s = PaymentMethodDataTinkoffBankTypeSbp
	case PaymentMethodDataTinkoffBankTypeSberLoan:
		*s = PaymentMethodDataTinkoffBankTypeSberLoan
	case PaymentMethodDataTinkoffBankTypeElectronicCertificate:
		*s = PaymentMethodDataTinkoffBankTypeElectronicCertificate
	case PaymentMethodDataTinkoffBankTypeSberBnpl:
		*s = PaymentMethodDataTinkoffBankTypeSberBnpl
	default:
		*s = PaymentMethodDataTinkoffBankType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataTinkoffBankType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataTinkoffBankType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodDataYooMoney) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodDataYooMoney) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodDataYooMoney = [1]string{
	0: "type",
}

// Decode decodes PaymentMethodDataYooMoney from json.
func (s *PaymentMethodDataYooMoney) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataYooMoney to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodDataYooMoney")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentMethodDataYooMoney) {
					name = jsonFieldsNameOfPaymentMethodDataYooMoney[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 *PaymentMethodDataYooMoney) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataYooMoney) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodDataYooMoneyType as json.
func (s PaymentMethodDataYooMoneyType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodDataYooMoneyType from json.
func (s *PaymentMethodDataYooMoneyType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodDataYooMoneyType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodDataYooMoneyType(v) {
	case PaymentMethodDataYooMoneyTypeBankCard:
		*s = PaymentMethodDataYooMoneyTypeBankCard
	case PaymentMethodDataYooMoneyTypeCash:
		*s = PaymentMethodDataYooMoneyTypeCash
	case PaymentMethodDataYooMoneyTypeSberbank:
		*s = PaymentMethodDataYooMoneyTypeSberbank
	case PaymentMethodDataYooMoneyTypeTinkoffBank:
		*s = PaymentMethodDataYooMoneyTypeTinkoffBank
	case PaymentMethodDataYooMoneyTypeYooMoney:
		*s = PaymentMethodDataYooMoneyTypeYooMoney
	case PaymentMethodDataYooMoneyTypeMobileBalance:
		*s = PaymentMethodDataYooMoneyTypeMobileBalance
	case PaymentMethodDataYooMoneyTypeB2bSberbank:
		*s = PaymentMethodDataYooMoneyTypeB2bSberbank
	case PaymentMethodDataYooMoneyTypeSbp:
		*s = PaymentMethodDataYooMoneyTypeSbp
	case PaymentMethodDataYooMoneyTypeSberLoan:
		*s = PaymentMethodDataYooMoneyTypeSberLoan
	case PaymentMethodDataYooMoneyTypeElectronicCertificate:
		*s = PaymentMethodDataYooMoneyTypeElectronicCertificate
	case PaymentMethodDataYooMoneyTypeSberBnpl:
		*s = PaymentMethodDataYooMoneyTypeSberBnpl
	default:
		*s = PaymentMethodDataYooMoneyType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodDataYooMoneyType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodDataYooMoneyType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodElectronicCertificate) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodElectronicCertificate) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
	{
		if s.ElectronicCertificate.Set {
			e.FieldStart("electronic_certificate")
			s.ElectronicCertificate.Encode(e)
		}
	}
	{
		if s.Articles != nil {
			e.FieldStart("articles")
			e.ArrStart()
			for _, elem := range s.Articles {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfPaymentMethodElectronicCertificate = [8]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "card",
	6: "electronic_certificate",
	7: "articles",
}

// Decode decodes PaymentMethodElectronicCertificate from json.
func (s *PaymentMethodElectronicCertificate) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodElectronicCertificate to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		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 "electronic_certificate":
			if err := func() error {
				s.ElectronicCertificate.Reset()
				if err := s.ElectronicCertificate.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"electronic_certificate\"")
			}
		case "articles":
			if err := func() error {
				s.Articles = make([]ElectronicCertificateApprovedPaymentArticle, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ElectronicCertificateApprovedPaymentArticle
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Articles = append(s.Articles, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"articles\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodElectronicCertificate")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodElectronicCertificate) {
					name = jsonFieldsNameOfPaymentMethodElectronicCertificate[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 *PaymentMethodElectronicCertificate) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodElectronicCertificate) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodElectronicCertificateCard) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodElectronicCertificateCard) encodeFields(e *jx.Encoder) {
	{
		if s.First6.Set {
			e.FieldStart("first6")
			s.First6.Encode(e)
		}
	}
	{
		e.FieldStart("last4")
		s.Last4.Encode(e)
	}
	{
		e.FieldStart("expiry_year")
		s.ExpiryYear.Encode(e)
	}
	{
		e.FieldStart("expiry_month")
		s.ExpiryMonth.Encode(e)
	}
	{
		e.FieldStart("card_type")
		s.CardType.Encode(e)
	}
	{
		if s.CardProduct.Set {
			e.FieldStart("card_product")
			s.CardProduct.Encode(e)
		}
	}
	{
		if s.IssuerCountry.Set {
			e.FieldStart("issuer_country")
			s.IssuerCountry.Encode(e)
		}
	}
	{
		if s.IssuerName.Set {
			e.FieldStart("issuer_name")
			s.IssuerName.Encode(e)
		}
	}
	{
		if s.Source.Set {
			e.FieldStart("source")
			s.Source.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodElectronicCertificateCard = [9]string{
	0: "first6",
	1: "last4",
	2: "expiry_year",
	3: "expiry_month",
	4: "card_type",
	5: "card_product",
	6: "issuer_country",
	7: "issuer_name",
	8: "source",
}

// Decode decodes PaymentMethodElectronicCertificateCard from json.
func (s *PaymentMethodElectronicCertificateCard) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodElectronicCertificateCard to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "first6":
			if err := func() error {
				s.First6.Reset()
				if err := s.First6.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first6\"")
			}
		case "last4":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Last4.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last4\"")
			}
		case "expiry_year":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.ExpiryYear.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_year\"")
			}
		case "expiry_month":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.ExpiryMonth.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expiry_month\"")
			}
		case "card_type":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.CardType.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_type\"")
			}
		case "card_product":
			if err := func() error {
				s.CardProduct.Reset()
				if err := s.CardProduct.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_product\"")
			}
		case "issuer_country":
			if err := func() error {
				s.IssuerCountry.Reset()
				if err := s.IssuerCountry.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_country\"")
			}
		case "issuer_name":
			if err := func() error {
				s.IssuerName.Reset()
				if err := s.IssuerName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_name\"")
			}
		case "source":
			if err := func() error {
				s.Source.Reset()
				if err := s.Source.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"source\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodElectronicCertificateCard")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00011110,
		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(jsonFieldsNameOfPaymentMethodElectronicCertificateCard) {
					name = jsonFieldsNameOfPaymentMethodElectronicCertificateCard[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 *PaymentMethodElectronicCertificateCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodElectronicCertificateCard) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodElectronicCertificateStatus as json.
func (s PaymentMethodElectronicCertificateStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodElectronicCertificateStatus from json.
func (s *PaymentMethodElectronicCertificateStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodElectronicCertificateStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodElectronicCertificateStatus(v) {
	case PaymentMethodElectronicCertificateStatusPending:
		*s = PaymentMethodElectronicCertificateStatusPending
	case PaymentMethodElectronicCertificateStatusActive:
		*s = PaymentMethodElectronicCertificateStatusActive
	case PaymentMethodElectronicCertificateStatusInactive:
		*s = PaymentMethodElectronicCertificateStatusInactive
	default:
		*s = PaymentMethodElectronicCertificateStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodElectronicCertificateStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodElectronicCertificateStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodGooglePay) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodGooglePay) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodGooglePay = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodGooglePay from json.
func (s *PaymentMethodGooglePay) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodGooglePay to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodGooglePay")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodGooglePay) {
					name = jsonFieldsNameOfPaymentMethodGooglePay[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 *PaymentMethodGooglePay) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodGooglePay) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodGooglePayStatus as json.
func (s PaymentMethodGooglePayStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodGooglePayStatus from json.
func (s *PaymentMethodGooglePayStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodGooglePayStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodGooglePayStatus(v) {
	case PaymentMethodGooglePayStatusPending:
		*s = PaymentMethodGooglePayStatusPending
	case PaymentMethodGooglePayStatusActive:
		*s = PaymentMethodGooglePayStatusActive
	case PaymentMethodGooglePayStatusInactive:
		*s = PaymentMethodGooglePayStatusInactive
	default:
		*s = PaymentMethodGooglePayStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodGooglePayStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodGooglePayStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodId as json.
func (s PaymentMethodId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PaymentMethodId from json.
func (s *PaymentMethodId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodInstallments) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodInstallments) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodInstallments = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodInstallments from json.
func (s *PaymentMethodInstallments) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodInstallments to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodInstallments")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodInstallments) {
					name = jsonFieldsNameOfPaymentMethodInstallments[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 *PaymentMethodInstallments) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodInstallments) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodInstallmentsStatus as json.
func (s PaymentMethodInstallmentsStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodInstallmentsStatus from json.
func (s *PaymentMethodInstallmentsStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodInstallmentsStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodInstallmentsStatus(v) {
	case PaymentMethodInstallmentsStatusPending:
		*s = PaymentMethodInstallmentsStatusPending
	case PaymentMethodInstallmentsStatusActive:
		*s = PaymentMethodInstallmentsStatusActive
	case PaymentMethodInstallmentsStatusInactive:
		*s = PaymentMethodInstallmentsStatusInactive
	default:
		*s = PaymentMethodInstallmentsStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodInstallmentsStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodInstallmentsStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodMobileBalance) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodMobileBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodMobileBalance = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodMobileBalance from json.
func (s *PaymentMethodMobileBalance) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodMobileBalance to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodMobileBalance")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodMobileBalance) {
					name = jsonFieldsNameOfPaymentMethodMobileBalance[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 *PaymentMethodMobileBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodMobileBalance) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodMobileBalanceStatus as json.
func (s PaymentMethodMobileBalanceStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodMobileBalanceStatus from json.
func (s *PaymentMethodMobileBalanceStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodMobileBalanceStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodMobileBalanceStatus(v) {
	case PaymentMethodMobileBalanceStatusPending:
		*s = PaymentMethodMobileBalanceStatusPending
	case PaymentMethodMobileBalanceStatusActive:
		*s = PaymentMethodMobileBalanceStatusActive
	case PaymentMethodMobileBalanceStatusInactive:
		*s = PaymentMethodMobileBalanceStatusInactive
	default:
		*s = PaymentMethodMobileBalanceStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodMobileBalanceStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodMobileBalanceStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodQiwi) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodQiwi) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodQiwi = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodQiwi from json.
func (s *PaymentMethodQiwi) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodQiwi to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodQiwi")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodQiwi) {
					name = jsonFieldsNameOfPaymentMethodQiwi[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 *PaymentMethodQiwi) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodQiwi) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodQiwiStatus as json.
func (s PaymentMethodQiwiStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodQiwiStatus from json.
func (s *PaymentMethodQiwiStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodQiwiStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodQiwiStatus(v) {
	case PaymentMethodQiwiStatusPending:
		*s = PaymentMethodQiwiStatusPending
	case PaymentMethodQiwiStatusActive:
		*s = PaymentMethodQiwiStatusActive
	case PaymentMethodQiwiStatusInactive:
		*s = PaymentMethodQiwiStatusInactive
	default:
		*s = PaymentMethodQiwiStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodQiwiStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodQiwiStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodSberBnpl) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodSberBnpl) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodSberBnpl = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodSberBnpl from json.
func (s *PaymentMethodSberBnpl) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberBnpl to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodSberBnpl")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodSberBnpl) {
					name = jsonFieldsNameOfPaymentMethodSberBnpl[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 *PaymentMethodSberBnpl) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberBnpl) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodSberBnplStatus as json.
func (s PaymentMethodSberBnplStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodSberBnplStatus from json.
func (s *PaymentMethodSberBnplStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberBnplStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodSberBnplStatus(v) {
	case PaymentMethodSberBnplStatusPending:
		*s = PaymentMethodSberBnplStatusPending
	case PaymentMethodSberBnplStatusActive:
		*s = PaymentMethodSberBnplStatusActive
	case PaymentMethodSberBnplStatusInactive:
		*s = PaymentMethodSberBnplStatusInactive
	default:
		*s = PaymentMethodSberBnplStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodSberBnplStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberBnplStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodSberLoan) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodSberLoan) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.LoanOption.Set {
			e.FieldStart("loan_option")
			s.LoanOption.Encode(e)
		}
	}
	{
		if s.DiscountAmount.Set {
			e.FieldStart("discount_amount")
			s.DiscountAmount.Encode(e)
		}
	}
	{
		if s.SuspendedUntil.Set {
			e.FieldStart("suspended_until")
			s.SuspendedUntil.Encode(e, json.EncodeDateTime)
		}
	}
}

var jsonFieldsNameOfPaymentMethodSberLoan = [8]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "loan_option",
	6: "discount_amount",
	7: "suspended_until",
}

// Decode decodes PaymentMethodSberLoan from json.
func (s *PaymentMethodSberLoan) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberLoan to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "loan_option":
			if err := func() error {
				s.LoanOption.Reset()
				if err := s.LoanOption.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"loan_option\"")
			}
		case "discount_amount":
			if err := func() error {
				s.DiscountAmount.Reset()
				if err := s.DiscountAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"discount_amount\"")
			}
		case "suspended_until":
			if err := func() error {
				s.SuspendedUntil.Reset()
				if err := s.SuspendedUntil.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"suspended_until\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodSberLoan")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodSberLoan) {
					name = jsonFieldsNameOfPaymentMethodSberLoan[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 *PaymentMethodSberLoan) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberLoan) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodSberLoanDiscountAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodSberLoanDiscountAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentMethodSberLoanDiscountAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PaymentMethodSberLoanDiscountAmount from json.
func (s *PaymentMethodSberLoanDiscountAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberLoanDiscountAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodSberLoanDiscountAmount")
	}
	// 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(jsonFieldsNameOfPaymentMethodSberLoanDiscountAmount) {
					name = jsonFieldsNameOfPaymentMethodSberLoanDiscountAmount[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 *PaymentMethodSberLoanDiscountAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberLoanDiscountAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodSberLoanStatus as json.
func (s PaymentMethodSberLoanStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodSberLoanStatus from json.
func (s *PaymentMethodSberLoanStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberLoanStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodSberLoanStatus(v) {
	case PaymentMethodSberLoanStatusPending:
		*s = PaymentMethodSberLoanStatusPending
	case PaymentMethodSberLoanStatusActive:
		*s = PaymentMethodSberLoanStatusActive
	case PaymentMethodSberLoanStatusInactive:
		*s = PaymentMethodSberLoanStatusInactive
	default:
		*s = PaymentMethodSberLoanStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodSberLoanStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberLoanStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodSberbank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodSberbank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodSberbank = [7]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "phone",
	6: "card",
}

// Decode decodes PaymentMethodSberbank from json.
func (s *PaymentMethodSberbank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberbank to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodSberbank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodSberbank) {
					name = jsonFieldsNameOfPaymentMethodSberbank[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 *PaymentMethodSberbank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberbank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodSberbankStatus as json.
func (s PaymentMethodSberbankStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodSberbankStatus from json.
func (s *PaymentMethodSberbankStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSberbankStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodSberbankStatus(v) {
	case PaymentMethodSberbankStatusPending:
		*s = PaymentMethodSberbankStatusPending
	case PaymentMethodSberbankStatusActive:
		*s = PaymentMethodSberbankStatusActive
	case PaymentMethodSberbankStatusInactive:
		*s = PaymentMethodSberbankStatusInactive
	default:
		*s = PaymentMethodSberbankStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodSberbankStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSberbankStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodSbp) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodSbp) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.SbpOperationID.Set {
			e.FieldStart("sbp_operation_id")
			s.SbpOperationID.Encode(e)
		}
	}
	{
		if s.PayerBankDetails.Set {
			e.FieldStart("payer_bank_details")
			s.PayerBankDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodSbp = [7]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "sbp_operation_id",
	6: "payer_bank_details",
}

// Decode decodes PaymentMethodSbp from json.
func (s *PaymentMethodSbp) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSbp to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "sbp_operation_id":
			if err := func() error {
				s.SbpOperationID.Reset()
				if err := s.SbpOperationID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sbp_operation_id\"")
			}
		case "payer_bank_details":
			if err := func() error {
				s.PayerBankDetails.Reset()
				if err := s.PayerBankDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payer_bank_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodSbp")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodSbp) {
					name = jsonFieldsNameOfPaymentMethodSbp[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 *PaymentMethodSbp) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSbp) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodSbpStatus as json.
func (s PaymentMethodSbpStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodSbpStatus from json.
func (s *PaymentMethodSbpStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodSbpStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodSbpStatus(v) {
	case PaymentMethodSbpStatusPending:
		*s = PaymentMethodSbpStatusPending
	case PaymentMethodSbpStatusActive:
		*s = PaymentMethodSbpStatusActive
	case PaymentMethodSbpStatusInactive:
		*s = PaymentMethodSbpStatusInactive
	default:
		*s = PaymentMethodSbpStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodSbpStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodSbpStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodStatus as json.
func (s PaymentMethodStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodStatus from json.
func (s *PaymentMethodStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodStatus(v) {
	case PaymentMethodStatusPending:
		*s = PaymentMethodStatusPending
	case PaymentMethodStatusActive:
		*s = PaymentMethodStatusActive
	case PaymentMethodStatusInactive:
		*s = PaymentMethodStatusInactive
	default:
		*s = PaymentMethodStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodTinkoffBank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodTinkoffBank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodTinkoffBank = [6]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "card",
}

// Decode decodes PaymentMethodTinkoffBank from json.
func (s *PaymentMethodTinkoffBank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodTinkoffBank to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodTinkoffBank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodTinkoffBank) {
					name = jsonFieldsNameOfPaymentMethodTinkoffBank[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 *PaymentMethodTinkoffBank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodTinkoffBank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodTinkoffBankStatus as json.
func (s PaymentMethodTinkoffBankStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodTinkoffBankStatus from json.
func (s *PaymentMethodTinkoffBankStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodTinkoffBankStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodTinkoffBankStatus(v) {
	case PaymentMethodTinkoffBankStatusPending:
		*s = PaymentMethodTinkoffBankStatusPending
	case PaymentMethodTinkoffBankStatusActive:
		*s = PaymentMethodTinkoffBankStatusActive
	case PaymentMethodTinkoffBankStatusInactive:
		*s = PaymentMethodTinkoffBankStatusInactive
	default:
		*s = PaymentMethodTinkoffBankStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodTinkoffBankStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodTinkoffBankStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodTitle as json.
func (s PaymentMethodTitle) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PaymentMethodTitle from json.
func (s *PaymentMethodTitle) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodTitle to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodTitle(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodTitle) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodTitle) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodType as json.
func (s PaymentMethodType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodType from json.
func (s *PaymentMethodType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodType(v) {
	case PaymentMethodTypeBankCard:
		*s = PaymentMethodTypeBankCard
	case PaymentMethodTypeCash:
		*s = PaymentMethodTypeCash
	case PaymentMethodTypeAlfabank:
		*s = PaymentMethodTypeAlfabank
	case PaymentMethodTypeWebmoney:
		*s = PaymentMethodTypeWebmoney
	case PaymentMethodTypeWechat:
		*s = PaymentMethodTypeWechat
	case PaymentMethodTypeApplePay:
		*s = PaymentMethodTypeApplePay
	case PaymentMethodTypeGooglePay:
		*s = PaymentMethodTypeGooglePay
	case PaymentMethodTypeQiwi:
		*s = PaymentMethodTypeQiwi
	case PaymentMethodTypeInstallments:
		*s = PaymentMethodTypeInstallments
	case PaymentMethodTypeYooMoney:
		*s = PaymentMethodTypeYooMoney
	case PaymentMethodTypeSberbank:
		*s = PaymentMethodTypeSberbank
	case PaymentMethodTypeMobileBalance:
		*s = PaymentMethodTypeMobileBalance
	case PaymentMethodTypeB2bSberbank:
		*s = PaymentMethodTypeB2bSberbank
	case PaymentMethodTypeTinkoffBank:
		*s = PaymentMethodTypeTinkoffBank
	case PaymentMethodTypeSbp:
		*s = PaymentMethodTypeSbp
	case PaymentMethodTypeSberLoan:
		*s = PaymentMethodTypeSberLoan
	case PaymentMethodTypeElectronicCertificate:
		*s = PaymentMethodTypeElectronicCertificate
	case PaymentMethodTypeSberBnpl:
		*s = PaymentMethodTypeSberBnpl
	default:
		*s = PaymentMethodType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodWeChat) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodWeChat) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodWeChat = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodWeChat from json.
func (s *PaymentMethodWeChat) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodWeChat to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodWeChat")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodWeChat) {
					name = jsonFieldsNameOfPaymentMethodWeChat[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 *PaymentMethodWeChat) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodWeChat) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodWeChatStatus as json.
func (s PaymentMethodWeChatStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodWeChatStatus from json.
func (s *PaymentMethodWeChatStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodWeChatStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodWeChatStatus(v) {
	case PaymentMethodWeChatStatusPending:
		*s = PaymentMethodWeChatStatusPending
	case PaymentMethodWeChatStatusActive:
		*s = PaymentMethodWeChatStatusActive
	case PaymentMethodWeChatStatusInactive:
		*s = PaymentMethodWeChatStatusInactive
	default:
		*s = PaymentMethodWeChatStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodWeChatStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodWeChatStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodWebmoney) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodWebmoney) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodWebmoney = [5]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
}

// Decode decodes PaymentMethodWebmoney from json.
func (s *PaymentMethodWebmoney) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodWebmoney to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodWebmoney")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodWebmoney) {
					name = jsonFieldsNameOfPaymentMethodWebmoney[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 *PaymentMethodWebmoney) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodWebmoney) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodWebmoneyStatus as json.
func (s PaymentMethodWebmoneyStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodWebmoneyStatus from json.
func (s *PaymentMethodWebmoneyStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodWebmoneyStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodWebmoneyStatus(v) {
	case PaymentMethodWebmoneyStatusPending:
		*s = PaymentMethodWebmoneyStatusPending
	case PaymentMethodWebmoneyStatusActive:
		*s = PaymentMethodWebmoneyStatusActive
	case PaymentMethodWebmoneyStatusInactive:
		*s = PaymentMethodWebmoneyStatusInactive
	default:
		*s = PaymentMethodWebmoneyStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodWebmoneyStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodWebmoneyStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodYooMoney) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodYooMoney) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.AccountNumber.Set {
			e.FieldStart("account_number")
			s.AccountNumber.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodYooMoney = [6]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "title",
	5: "account_number",
}

// Decode decodes PaymentMethodYooMoney from json.
func (s *PaymentMethodYooMoney) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodYooMoney to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "account_number":
			if err := func() error {
				s.AccountNumber.Reset()
				if err := s.AccountNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodYooMoney")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentMethodYooMoney) {
					name = jsonFieldsNameOfPaymentMethodYooMoney[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 *PaymentMethodYooMoney) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodYooMoney) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodYooMoneyStatus as json.
func (s PaymentMethodYooMoneyStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodYooMoneyStatus from json.
func (s *PaymentMethodYooMoneyStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodYooMoneyStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodYooMoneyStatus(v) {
	case PaymentMethodYooMoneyStatusPending:
		*s = PaymentMethodYooMoneyStatusPending
	case PaymentMethodYooMoneyStatusActive:
		*s = PaymentMethodYooMoneyStatusActive
	case PaymentMethodYooMoneyStatusInactive:
		*s = PaymentMethodYooMoneyStatusInactive
	default:
		*s = PaymentMethodYooMoneyStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodYooMoneyStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodYooMoneyStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodsConfirmationDataRedirect) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodsConfirmationDataRedirect) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Enforce.Set {
			e.FieldStart("enforce")
			s.Enforce.Encode(e)
		}
	}
	{
		e.FieldStart("return_url")
		e.Str(s.ReturnURL)
	}
	{
		if s.Locale.Set {
			e.FieldStart("locale")
			s.Locale.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodsConfirmationDataRedirect = [4]string{
	0: "type",
	1: "enforce",
	2: "return_url",
	3: "locale",
}

// Decode decodes PaymentMethodsConfirmationDataRedirect from json.
func (s *PaymentMethodsConfirmationDataRedirect) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsConfirmationDataRedirect to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "enforce":
			if err := func() error {
				s.Enforce.Reset()
				if err := s.Enforce.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"enforce\"")
			}
		case "return_url":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.ReturnURL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		case "locale":
			if err := func() error {
				s.Locale.Reset()
				if err := s.Locale.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"locale\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodsConfirmationDataRedirect")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000101,
	} {
		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(jsonFieldsNameOfPaymentMethodsConfirmationDataRedirect) {
					name = jsonFieldsNameOfPaymentMethodsConfirmationDataRedirect[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 *PaymentMethodsConfirmationDataRedirect) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsConfirmationDataRedirect) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentMethodsConfirmationRedirect) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentMethodsConfirmationRedirect) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("confirmation_url")
		e.Str(s.ConfirmationURL)
	}
	{
		if s.Enforce.Set {
			e.FieldStart("enforce")
			s.Enforce.Encode(e)
		}
	}
	{
		if s.ReturnURL.Set {
			e.FieldStart("return_url")
			s.ReturnURL.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentMethodsConfirmationRedirect = [4]string{
	0: "type",
	1: "confirmation_url",
	2: "enforce",
	3: "return_url",
}

// Decode decodes PaymentMethodsConfirmationRedirect from json.
func (s *PaymentMethodsConfirmationRedirect) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsConfirmationRedirect to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "confirmation_url":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ConfirmationURL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation_url\"")
			}
		case "enforce":
			if err := func() error {
				s.Enforce.Reset()
				if err := s.Enforce.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"enforce\"")
			}
		case "return_url":
			if err := func() error {
				s.ReturnURL.Reset()
				if err := s.ReturnURL.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"return_url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentMethodsConfirmationRedirect")
	}
	// 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(jsonFieldsNameOfPaymentMethodsConfirmationRedirect) {
					name = jsonFieldsNameOfPaymentMethodsConfirmationRedirect[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 *PaymentMethodsConfirmationRedirect) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsConfirmationRedirect) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsConfirmationType as json.
func (s PaymentMethodsConfirmationType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentMethodsConfirmationType from json.
func (s *PaymentMethodsConfirmationType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsConfirmationType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentMethodsConfirmationType(v) {
	case PaymentMethodsConfirmationTypeRedirect:
		*s = PaymentMethodsConfirmationTypeRedirect
	default:
		*s = PaymentMethodsConfirmationType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodsConfirmationType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsConfirmationType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPaymentMethodIDGetInternalServerError as json.
func (s *PaymentMethodsPaymentMethodIDGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PaymentMethodsPaymentMethodIDGetInternalServerError from json.
func (s *PaymentMethodsPaymentMethodIDGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPaymentMethodIDGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodsPaymentMethodIDGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentMethodsPaymentMethodIDGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPaymentMethodIDGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPaymentMethodIDGetOK as json.
func (s PaymentMethodsPaymentMethodIDGetOK) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentMethodsPaymentMethodIDGetOK) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPaymentMethodIDGetOK:
		e.FieldStart("type")
		e.Str("SavePaymentMethodBankCard")
		{
			s := s.SavePaymentMethodBankCard
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				e.FieldStart("holder")
				s.Holder.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Confirmation.Set {
					e.FieldStart("confirmation")
					s.Confirmation.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentMethodsPaymentMethodIDGetOK from json.
func (s *PaymentMethodsPaymentMethodIDGetOK) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPaymentMethodIDGetOK to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SavePaymentMethodBankCard":
					s.Type = SavePaymentMethodBankCardPaymentMethodsPaymentMethodIDGetOK
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPaymentMethodIDGetOK:
		if err := s.SavePaymentMethodBankCard.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodsPaymentMethodIDGetOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPaymentMethodIDGetOK) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPaymentMethodIDGetTooManyRequests as json.
func (s *PaymentMethodsPaymentMethodIDGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PaymentMethodsPaymentMethodIDGetTooManyRequests from json.
func (s *PaymentMethodsPaymentMethodIDGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPaymentMethodIDGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodsPaymentMethodIDGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentMethodsPaymentMethodIDGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPaymentMethodIDGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPostInternalServerError as json.
func (s *PaymentMethodsPostInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PaymentMethodsPostInternalServerError from json.
func (s *PaymentMethodsPostInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPostInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodsPostInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentMethodsPostInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPostInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPostOK as json.
func (s PaymentMethodsPostOK) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentMethodsPostOK) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPostOK:
		e.FieldStart("type")
		e.Str("SavePaymentMethodBankCard")
		{
			s := s.SavePaymentMethodBankCard
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				e.FieldStart("holder")
				s.Holder.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Confirmation.Set {
					e.FieldStart("confirmation")
					s.Confirmation.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentMethodsPostOK from json.
func (s *PaymentMethodsPostOK) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPostOK to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SavePaymentMethodBankCard":
					s.Type = SavePaymentMethodBankCardPaymentMethodsPostOK
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPostOK:
		if err := s.SavePaymentMethodBankCard.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodsPostOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPostOK) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPostReq as json.
func (s PaymentMethodsPostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentMethodsPostReq) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SavePaymentMethodDataBankCardPaymentMethodsPostReq:
		e.FieldStart("type")
		e.Str("SavePaymentMethodDataBankCard")
		{
			s := s.SavePaymentMethodDataBankCard
			{
				if s.Holder.Set {
					e.FieldStart("holder")
					s.Holder.Encode(e)
				}
			}
			{
				if s.ClientIP.Set {
					e.FieldStart("client_ip")
					s.ClientIP.Encode(e)
				}
			}
			{
				if s.Confirmation.Set {
					e.FieldStart("confirmation")
					s.Confirmation.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentMethodsPostReq from json.
func (s *PaymentMethodsPostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPostReq to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SavePaymentMethodDataBankCard":
					s.Type = SavePaymentMethodDataBankCardPaymentMethodsPostReq
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SavePaymentMethodDataBankCardPaymentMethodsPostReq:
		if err := s.SavePaymentMethodDataBankCard.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentMethodsPostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentMethodsPostTooManyRequests as json.
func (s *PaymentMethodsPostTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PaymentMethodsPostTooManyRequests from json.
func (s *PaymentMethodsPostTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentMethodsPostTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentMethodsPostTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentMethodsPostTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentMethodsPostTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOrderDataUtilities) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOrderDataUtilities) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("payment_purpose")
		e.Str(s.PaymentPurpose)
	}
	{
		e.FieldStart("recipient")
		s.Recipient.Encode(e)
	}
	{
		if s.Kbk.Set {
			e.FieldStart("kbk")
			s.Kbk.Encode(e)
		}
	}
	{
		if s.Oktmo.Set {
			e.FieldStart("oktmo")
			s.Oktmo.Encode(e)
		}
	}
	{
		if s.PaymentPeriod.Set {
			e.FieldStart("payment_period")
			s.PaymentPeriod.Encode(e)
		}
	}
	{
		if s.PaymentDocumentID.Set {
			e.FieldStart("payment_document_id")
			s.PaymentDocumentID.Encode(e)
		}
	}
	{
		if s.PaymentDocumentNumber.Set {
			e.FieldStart("payment_document_number")
			s.PaymentDocumentNumber.Encode(e)
		}
	}
	{
		if s.AccountNumber.Set {
			e.FieldStart("account_number")
			s.AccountNumber.Encode(e)
		}
	}
	{
		if s.UnifiedAccountNumber.Set {
			e.FieldStart("unified_account_number")
			s.UnifiedAccountNumber.Encode(e)
		}
	}
	{
		if s.ServiceID.Set {
			e.FieldStart("service_id")
			s.ServiceID.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentOrderDataUtilities = [12]string{
	0:  "type",
	1:  "amount",
	2:  "payment_purpose",
	3:  "recipient",
	4:  "kbk",
	5:  "oktmo",
	6:  "payment_period",
	7:  "payment_document_id",
	8:  "payment_document_number",
	9:  "account_number",
	10: "unified_account_number",
	11: "service_id",
}

// Decode decodes PaymentOrderDataUtilities from json.
func (s *PaymentOrderDataUtilities) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOrderDataUtilities to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "payment_purpose":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.PaymentPurpose = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_purpose\"")
			}
		case "recipient":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Recipient.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"recipient\"")
			}
		case "kbk":
			if err := func() error {
				s.Kbk.Reset()
				if err := s.Kbk.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"kbk\"")
			}
		case "oktmo":
			if err := func() error {
				s.Oktmo.Reset()
				if err := s.Oktmo.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"oktmo\"")
			}
		case "payment_period":
			if err := func() error {
				s.PaymentPeriod.Reset()
				if err := s.PaymentPeriod.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_period\"")
			}
		case "payment_document_id":
			if err := func() error {
				s.PaymentDocumentID.Reset()
				if err := s.PaymentDocumentID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_document_id\"")
			}
		case "payment_document_number":
			if err := func() error {
				s.PaymentDocumentNumber.Reset()
				if err := s.PaymentDocumentNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_document_number\"")
			}
		case "account_number":
			if err := func() error {
				s.AccountNumber.Reset()
				if err := s.AccountNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		case "unified_account_number":
			if err := func() error {
				s.UnifiedAccountNumber.Reset()
				if err := s.UnifiedAccountNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"unified_account_number\"")
			}
		case "service_id":
			if err := func() error {
				s.ServiceID.Reset()
				if err := s.ServiceID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"service_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOrderDataUtilities")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00001111,
		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(jsonFieldsNameOfPaymentOrderDataUtilities) {
					name = jsonFieldsNameOfPaymentOrderDataUtilities[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 *PaymentOrderDataUtilities) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOrderDataUtilities) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOrderDataUtilitiesAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOrderDataUtilitiesAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentOrderDataUtilitiesAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PaymentOrderDataUtilitiesAmount from json.
func (s *PaymentOrderDataUtilitiesAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOrderDataUtilitiesAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOrderDataUtilitiesAmount")
	}
	// 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(jsonFieldsNameOfPaymentOrderDataUtilitiesAmount) {
					name = jsonFieldsNameOfPaymentOrderDataUtilitiesAmount[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 *PaymentOrderDataUtilitiesAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOrderDataUtilitiesAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOrderDataUtilitiesRecipient) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOrderDataUtilitiesRecipient) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("name")
		e.Str(s.Name)
	}
	{
		e.FieldStart("inn")
		e.Str(s.Inn)
	}
	{
		e.FieldStart("kpp")
		e.Str(s.Kpp)
	}
	{
		e.FieldStart("bank")
		s.Bank.Encode(e)
	}
}

var jsonFieldsNameOfPaymentOrderDataUtilitiesRecipient = [4]string{
	0: "name",
	1: "inn",
	2: "kpp",
	3: "bank",
}

// Decode decodes PaymentOrderDataUtilitiesRecipient from json.
func (s *PaymentOrderDataUtilitiesRecipient) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOrderDataUtilitiesRecipient 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 "inn":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Inn = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"inn\"")
			}
		case "kpp":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.Kpp = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"kpp\"")
			}
		case "bank":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Bank.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOrderDataUtilitiesRecipient")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentOrderDataUtilitiesRecipient) {
					name = jsonFieldsNameOfPaymentOrderDataUtilitiesRecipient[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 *PaymentOrderDataUtilitiesRecipient) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOrderDataUtilitiesRecipient) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOrderDataUtilitiesRecipientBank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOrderDataUtilitiesRecipientBank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("name")
		e.Str(s.Name)
	}
	{
		e.FieldStart("bic")
		e.Str(s.Bic)
	}
	{
		e.FieldStart("account")
		e.Str(s.Account)
	}
	{
		e.FieldStart("correspondent_account")
		e.Str(s.CorrespondentAccount)
	}
}

var jsonFieldsNameOfPaymentOrderDataUtilitiesRecipientBank = [4]string{
	0: "name",
	1: "bic",
	2: "account",
	3: "correspondent_account",
}

// Decode decodes PaymentOrderDataUtilitiesRecipientBank from json.
func (s *PaymentOrderDataUtilitiesRecipientBank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOrderDataUtilitiesRecipientBank 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 "bic":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Bic = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bic\"")
			}
		case "account":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.Account = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account\"")
			}
		case "correspondent_account":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Str()
				s.CorrespondentAccount = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"correspondent_account\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOrderDataUtilitiesRecipientBank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPaymentOrderDataUtilitiesRecipientBank) {
					name = jsonFieldsNameOfPaymentOrderDataUtilitiesRecipientBank[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 *PaymentOrderDataUtilitiesRecipientBank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOrderDataUtilitiesRecipientBank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentOrderDataUtilitiesType as json.
func (s PaymentOrderDataUtilitiesType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentOrderDataUtilitiesType from json.
func (s *PaymentOrderDataUtilitiesType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOrderDataUtilitiesType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentOrderDataUtilitiesType(v) {
	case PaymentOrderDataUtilitiesTypeUtilities:
		*s = PaymentOrderDataUtilitiesTypeUtilities
	default:
		*s = PaymentOrderDataUtilitiesType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentOrderDataUtilitiesType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOrderDataUtilitiesType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOverviewStatementData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOverviewStatementData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("delivery_method")
		s.DeliveryMethod.Encode(e)
	}
}

var jsonFieldsNameOfPaymentOverviewStatementData = [2]string{
	0: "type",
	1: "delivery_method",
}

// Decode decodes PaymentOverviewStatementData from json.
func (s *PaymentOverviewStatementData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOverviewStatementData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "delivery_method":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.DeliveryMethod.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"delivery_method\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOverviewStatementData")
	}
	// 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(jsonFieldsNameOfPaymentOverviewStatementData) {
					name = jsonFieldsNameOfPaymentOverviewStatementData[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 *PaymentOverviewStatementData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOverviewStatementData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentOverviewStatementDataType as json.
func (s PaymentOverviewStatementDataType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentOverviewStatementDataType from json.
func (s *PaymentOverviewStatementDataType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOverviewStatementDataType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentOverviewStatementDataType(v) {
	case PaymentOverviewStatementDataTypePaymentOverview:
		*s = PaymentOverviewStatementDataTypePaymentOverview
	default:
		*s = PaymentOverviewStatementDataType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentOverviewStatementDataType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOverviewStatementDataType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentOverviewStatementDeliveryMethodType as json.
func (s PaymentOverviewStatementDeliveryMethodType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentOverviewStatementDeliveryMethodType from json.
func (s *PaymentOverviewStatementDeliveryMethodType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOverviewStatementDeliveryMethodType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentOverviewStatementDeliveryMethodType(v) {
	case PaymentOverviewStatementDeliveryMethodTypeEmail:
		*s = PaymentOverviewStatementDeliveryMethodTypeEmail
	default:
		*s = PaymentOverviewStatementDeliveryMethodType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentOverviewStatementDeliveryMethodType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOverviewStatementDeliveryMethodType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentOverviewStatementEmailDeliveryMethod) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentOverviewStatementEmailDeliveryMethod) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("email")
		e.Str(s.Email)
	}
}

var jsonFieldsNameOfPaymentOverviewStatementEmailDeliveryMethod = [2]string{
	0: "type",
	1: "email",
}

// Decode decodes PaymentOverviewStatementEmailDeliveryMethod from json.
func (s *PaymentOverviewStatementEmailDeliveryMethod) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentOverviewStatementEmailDeliveryMethod to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "email":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Email = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"email\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentOverviewStatementEmailDeliveryMethod")
	}
	// 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(jsonFieldsNameOfPaymentOverviewStatementEmailDeliveryMethod) {
					name = jsonFieldsNameOfPaymentOverviewStatementEmailDeliveryMethod[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 *PaymentOverviewStatementEmailDeliveryMethod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentOverviewStatementEmailDeliveryMethod) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentPaymentMethod as json.
func (s PaymentPaymentMethod) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentPaymentMethod) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PaymentMethodBankCardPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodBankCard")
		{
			s := s.PaymentMethodBankCard
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	case PaymentMethodCashPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodCash")
		{
			s := s.PaymentMethodCash
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodQiwiPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodQiwi")
		{
			s := s.PaymentMethodQiwi
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodAlfabankPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodAlfabank")
		{
			s := s.PaymentMethodAlfabank
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Login.Set {
					e.FieldStart("login")
					s.Login.Encode(e)
				}
			}
		}
	case PaymentMethodWebmoneyPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodWebmoney")
		{
			s := s.PaymentMethodWebmoney
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodSberbankPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodSberbank")
		{
			s := s.PaymentMethodSberbank
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Phone.Set {
					e.FieldStart("phone")
					s.Phone.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	case PaymentMethodTinkoffBankPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodTinkoffBank")
		{
			s := s.PaymentMethodTinkoffBank
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	case PaymentMethodYooMoneyPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodYooMoney")
		{
			s := s.PaymentMethodYooMoney
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.AccountNumber.Set {
					e.FieldStart("account_number")
					s.AccountNumber.Encode(e)
				}
			}
		}
	case PaymentMethodApplePayPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodApplePay")
		{
			s := s.PaymentMethodApplePay
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodGooglePayPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodGooglePay")
		{
			s := s.PaymentMethodGooglePay
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodMobileBalancePaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodMobileBalance")
		{
			s := s.PaymentMethodMobileBalance
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodInstallmentsPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodInstallments")
		{
			s := s.PaymentMethodInstallments
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodB2bSberbankPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodB2bSberbank")
		{
			s := s.PaymentMethodB2bSberbank
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				e.FieldStart("payment_purpose")
				s.PaymentPurpose.Encode(e)
			}
			{
				e.FieldStart("vat_data")
				s.VatData.Encode(e)
			}
			{
				if s.PayerBankDetails.Set {
					e.FieldStart("payer_bank_details")
					s.PayerBankDetails.Encode(e)
				}
			}
		}
	case PaymentMethodWeChatPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodWeChat")
		{
			s := s.PaymentMethodWeChat
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	case PaymentMethodSbpPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodSbp")
		{
			s := s.PaymentMethodSbp
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.SbpOperationID.Set {
					e.FieldStart("sbp_operation_id")
					s.SbpOperationID.Encode(e)
				}
			}
			{
				if s.PayerBankDetails.Set {
					e.FieldStart("payer_bank_details")
					s.PayerBankDetails.Encode(e)
				}
			}
		}
	case PaymentMethodSberLoanPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodSberLoan")
		{
			s := s.PaymentMethodSberLoan
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.LoanOption.Set {
					e.FieldStart("loan_option")
					s.LoanOption.Encode(e)
				}
			}
			{
				if s.DiscountAmount.Set {
					e.FieldStart("discount_amount")
					s.DiscountAmount.Encode(e)
				}
			}
			{
				if s.SuspendedUntil.Set {
					e.FieldStart("suspended_until")
					s.SuspendedUntil.Encode(e, json.EncodeDateTime)
				}
			}
		}
	case PaymentMethodElectronicCertificatePaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodElectronicCertificate")
		{
			s := s.PaymentMethodElectronicCertificate
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
			{
				if s.ElectronicCertificate.Set {
					e.FieldStart("electronic_certificate")
					s.ElectronicCertificate.Encode(e)
				}
			}
			{
				if s.Articles != nil {
					e.FieldStart("articles")
					e.ArrStart()
					for _, elem := range s.Articles {
						elem.Encode(e)
					}
					e.ArrEnd()
				}
			}
		}
	case PaymentMethodSberBnplPaymentPaymentMethod:
		e.FieldStart("type")
		e.Str("PaymentMethodSberBnpl")
		{
			s := s.PaymentMethodSberBnpl
			{
				e.FieldStart("id")
				e.Str(s.ID)
			}
			{
				e.FieldStart("saved")
				e.Bool(s.Saved)
			}
			{
				e.FieldStart("status")
				s.Status.Encode(e)
			}
			{
				if s.Title.Set {
					e.FieldStart("title")
					s.Title.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentPaymentMethod from json.
func (s *PaymentPaymentMethod) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentPaymentMethod to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "PaymentMethodBankCard":
					s.Type = PaymentMethodBankCardPaymentPaymentMethod
					found = true
				case "PaymentMethodCash":
					s.Type = PaymentMethodCashPaymentPaymentMethod
					found = true
				case "PaymentMethodQiwi":
					s.Type = PaymentMethodQiwiPaymentPaymentMethod
					found = true
				case "PaymentMethodAlfabank":
					s.Type = PaymentMethodAlfabankPaymentPaymentMethod
					found = true
				case "PaymentMethodWebmoney":
					s.Type = PaymentMethodWebmoneyPaymentPaymentMethod
					found = true
				case "PaymentMethodSberbank":
					s.Type = PaymentMethodSberbankPaymentPaymentMethod
					found = true
				case "PaymentMethodTinkoffBank":
					s.Type = PaymentMethodTinkoffBankPaymentPaymentMethod
					found = true
				case "PaymentMethodYooMoney":
					s.Type = PaymentMethodYooMoneyPaymentPaymentMethod
					found = true
				case "PaymentMethodApplePay":
					s.Type = PaymentMethodApplePayPaymentPaymentMethod
					found = true
				case "PaymentMethodGooglePay":
					s.Type = PaymentMethodGooglePayPaymentPaymentMethod
					found = true
				case "PaymentMethodMobileBalance":
					s.Type = PaymentMethodMobileBalancePaymentPaymentMethod
					found = true
				case "PaymentMethodInstallments":
					s.Type = PaymentMethodInstallmentsPaymentPaymentMethod
					found = true
				case "PaymentMethodB2bSberbank":
					s.Type = PaymentMethodB2bSberbankPaymentPaymentMethod
					found = true
				case "PaymentMethodWeChat":
					s.Type = PaymentMethodWeChatPaymentPaymentMethod
					found = true
				case "PaymentMethodSbp":
					s.Type = PaymentMethodSbpPaymentPaymentMethod
					found = true
				case "PaymentMethodSberLoan":
					s.Type = PaymentMethodSberLoanPaymentPaymentMethod
					found = true
				case "PaymentMethodElectronicCertificate":
					s.Type = PaymentMethodElectronicCertificatePaymentPaymentMethod
					found = true
				case "PaymentMethodSberBnpl":
					s.Type = PaymentMethodSberBnplPaymentPaymentMethod
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PaymentMethodBankCardPaymentPaymentMethod:
		if err := s.PaymentMethodBankCard.Decode(d); err != nil {
			return err
		}
	case PaymentMethodCashPaymentPaymentMethod:
		if err := s.PaymentMethodCash.Decode(d); err != nil {
			return err
		}
	case PaymentMethodQiwiPaymentPaymentMethod:
		if err := s.PaymentMethodQiwi.Decode(d); err != nil {
			return err
		}
	case PaymentMethodAlfabankPaymentPaymentMethod:
		if err := s.PaymentMethodAlfabank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodWebmoneyPaymentPaymentMethod:
		if err := s.PaymentMethodWebmoney.Decode(d); err != nil {
			return err
		}
	case PaymentMethodSberbankPaymentPaymentMethod:
		if err := s.PaymentMethodSberbank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodTinkoffBankPaymentPaymentMethod:
		if err := s.PaymentMethodTinkoffBank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodYooMoneyPaymentPaymentMethod:
		if err := s.PaymentMethodYooMoney.Decode(d); err != nil {
			return err
		}
	case PaymentMethodApplePayPaymentPaymentMethod:
		if err := s.PaymentMethodApplePay.Decode(d); err != nil {
			return err
		}
	case PaymentMethodGooglePayPaymentPaymentMethod:
		if err := s.PaymentMethodGooglePay.Decode(d); err != nil {
			return err
		}
	case PaymentMethodMobileBalancePaymentPaymentMethod:
		if err := s.PaymentMethodMobileBalance.Decode(d); err != nil {
			return err
		}
	case PaymentMethodInstallmentsPaymentPaymentMethod:
		if err := s.PaymentMethodInstallments.Decode(d); err != nil {
			return err
		}
	case PaymentMethodB2bSberbankPaymentPaymentMethod:
		if err := s.PaymentMethodB2bSberbank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodWeChatPaymentPaymentMethod:
		if err := s.PaymentMethodWeChat.Decode(d); err != nil {
			return err
		}
	case PaymentMethodSbpPaymentPaymentMethod:
		if err := s.PaymentMethodSbp.Decode(d); err != nil {
			return err
		}
	case PaymentMethodSberLoanPaymentPaymentMethod:
		if err := s.PaymentMethodSberLoan.Decode(d); err != nil {
			return err
		}
	case PaymentMethodElectronicCertificatePaymentPaymentMethod:
		if err := s.PaymentMethodElectronicCertificate.Decode(d); err != nil {
			return err
		}
	case PaymentMethodSberBnplPaymentPaymentMethod:
		if err := s.PaymentMethodSberBnpl.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentPaymentMethod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentPaymentMethod) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentPeriod) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentPeriod) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("month")
		e.Int(s.Month)
	}
	{
		e.FieldStart("year")
		e.Int(s.Year)
	}
}

var jsonFieldsNameOfPaymentPeriod = [2]string{
	0: "month",
	1: "year",
}

// Decode decodes PaymentPeriod from json.
func (s *PaymentPeriod) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentPeriod to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "month":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.Month = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"month\"")
			}
		case "year":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Int()
				s.Year = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"year\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentPeriod")
	}
	// 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(jsonFieldsNameOfPaymentPeriod) {
					name = jsonFieldsNameOfPaymentPeriod[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 *PaymentPeriod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentPeriod) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentPurpose as json.
func (s PaymentPurpose) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PaymentPurpose from json.
func (s *PaymentPurpose) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentPurpose to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentPurpose(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentPurpose) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentPurpose) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentReceiptRegistration as json.
func (s PaymentReceiptRegistration) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentReceiptRegistration from json.
func (s *PaymentReceiptRegistration) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentReceiptRegistration to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentReceiptRegistration(v) {
	case PaymentReceiptRegistrationPending:
		*s = PaymentReceiptRegistrationPending
	case PaymentReceiptRegistrationSucceeded:
		*s = PaymentReceiptRegistrationSucceeded
	case PaymentReceiptRegistrationCanceled:
		*s = PaymentReceiptRegistrationCanceled
	default:
		*s = PaymentReceiptRegistration(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentReceiptRegistration) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentReceiptRegistration) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentRecipient) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentRecipient) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		s.AccountID.Encode(e)
	}
	{
		e.FieldStart("gateway_id")
		s.GatewayID.Encode(e)
	}
}

var jsonFieldsNameOfPaymentRecipient = [2]string{
	0: "account_id",
	1: "gateway_id",
}

// Decode decodes PaymentRecipient from json.
func (s *PaymentRecipient) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentRecipient to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.AccountID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "gateway_id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.GatewayID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gateway_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentRecipient")
	}
	// 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(jsonFieldsNameOfPaymentRecipient) {
					name = jsonFieldsNameOfPaymentRecipient[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 *PaymentRecipient) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentRecipient) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentRefundedAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentRefundedAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentRefundedAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PaymentRefundedAmount from json.
func (s *PaymentRefundedAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentRefundedAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentRefundedAmount")
	}
	// 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(jsonFieldsNameOfPaymentRefundedAmount) {
					name = jsonFieldsNameOfPaymentRefundedAmount[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 *PaymentRefundedAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentRefundedAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentStatus as json.
func (s PaymentStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PaymentStatus from json.
func (s *PaymentStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PaymentStatus(v) {
	case PaymentStatusPending:
		*s = PaymentStatusPending
	case PaymentStatusWaitingForCapture:
		*s = PaymentStatusWaitingForCapture
	case PaymentStatusSucceeded:
		*s = PaymentStatusSucceeded
	case PaymentStatusCanceled:
		*s = PaymentStatusCanceled
	default:
		*s = PaymentStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentToken as json.
func (s PaymentToken) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PaymentToken from json.
func (s *PaymentToken) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentToken to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PaymentToken(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentToken) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentToken) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPaymentIDCapturePostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPaymentIDCapturePostReq) encodeFields(e *jx.Encoder) {
	{
		if s.Amount.Set {
			e.FieldStart("amount")
			s.Amount.Encode(e)
		}
	}
	{
		if s.Receipt.Set {
			e.FieldStart("receipt")
			s.Receipt.Encode(e)
		}
	}
	{
		if s.Airline.Set {
			e.FieldStart("airline")
			s.Airline.Encode(e)
		}
	}
	{
		if s.Transfers != nil {
			e.FieldStart("transfers")
			e.ArrStart()
			for _, elem := range s.Transfers {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentsPaymentIDCapturePostReq = [5]string{
	0: "amount",
	1: "receipt",
	2: "airline",
	3: "transfers",
	4: "deal",
}

// Decode decodes PaymentsPaymentIDCapturePostReq from json.
func (s *PaymentsPaymentIDCapturePostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPaymentIDCapturePostReq to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			if err := func() error {
				s.Amount.Reset()
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "receipt":
			if err := func() error {
				s.Receipt.Reset()
				if err := s.Receipt.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt\"")
			}
		case "airline":
			if err := func() error {
				s.Airline.Reset()
				if err := s.Airline.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"airline\"")
			}
		case "transfers":
			if err := func() error {
				s.Transfers = make([]TransferData, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem TransferData
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Transfers = append(s.Transfers, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"transfers\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPaymentIDCapturePostReq")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentsPaymentIDCapturePostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPaymentIDCapturePostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPaymentIDCapturePostReqAirline) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPaymentIDCapturePostReqAirline) encodeFields(e *jx.Encoder) {
	{
		if s.TicketNumber.Set {
			e.FieldStart("ticket_number")
			s.TicketNumber.Encode(e)
		}
	}
	{
		if s.BookingReference.Set {
			e.FieldStart("booking_reference")
			s.BookingReference.Encode(e)
		}
	}
	{
		if s.Passengers != nil {
			e.FieldStart("passengers")
			e.ArrStart()
			for _, elem := range s.Passengers {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Legs != nil {
			e.FieldStart("legs")
			e.ArrStart()
			for _, elem := range s.Legs {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfPaymentsPaymentIDCapturePostReqAirline = [4]string{
	0: "ticket_number",
	1: "booking_reference",
	2: "passengers",
	3: "legs",
}

// Decode decodes PaymentsPaymentIDCapturePostReqAirline from json.
func (s *PaymentsPaymentIDCapturePostReqAirline) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPaymentIDCapturePostReqAirline to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "ticket_number":
			if err := func() error {
				s.TicketNumber.Reset()
				if err := s.TicketNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ticket_number\"")
			}
		case "booking_reference":
			if err := func() error {
				s.BookingReference.Reset()
				if err := s.BookingReference.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"booking_reference\"")
			}
		case "passengers":
			if err := func() error {
				s.Passengers = make([]AirlinePassenger, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem AirlinePassenger
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Passengers = append(s.Passengers, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"passengers\"")
			}
		case "legs":
			if err := func() error {
				s.Legs = make([]AirlineLeg, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem AirlineLeg
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Legs = append(s.Legs, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"legs\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPaymentIDCapturePostReqAirline")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentsPaymentIDCapturePostReqAirline) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPaymentIDCapturePostReqAirline) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPaymentIDCapturePostReqAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPaymentIDCapturePostReqAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentsPaymentIDCapturePostReqAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PaymentsPaymentIDCapturePostReqAmount from json.
func (s *PaymentsPaymentIDCapturePostReqAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPaymentIDCapturePostReqAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPaymentIDCapturePostReqAmount")
	}
	// 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(jsonFieldsNameOfPaymentsPaymentIDCapturePostReqAmount) {
					name = jsonFieldsNameOfPaymentsPaymentIDCapturePostReqAmount[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 *PaymentsPaymentIDCapturePostReqAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPaymentIDCapturePostReqAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPaymentIDCapturePostReqDeal) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPaymentIDCapturePostReqDeal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("settlements")
		s.Settlements.Encode(e)
	}
}

var jsonFieldsNameOfPaymentsPaymentIDCapturePostReqDeal = [1]string{
	0: "settlements",
}

// Decode decodes PaymentsPaymentIDCapturePostReqDeal from json.
func (s *PaymentsPaymentIDCapturePostReqDeal) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPaymentIDCapturePostReqDeal to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "settlements":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Settlements.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"settlements\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPaymentIDCapturePostReqDeal")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPaymentsPaymentIDCapturePostReqDeal) {
					name = jsonFieldsNameOfPaymentsPaymentIDCapturePostReqDeal[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 *PaymentsPaymentIDCapturePostReqDeal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPaymentIDCapturePostReqDeal) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPostReq) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Receipt.Set {
			e.FieldStart("receipt")
			s.Receipt.Encode(e)
		}
	}
	{
		if s.Recipient.Set {
			e.FieldStart("recipient")
			s.Recipient.Encode(e)
		}
	}
	{
		if s.PaymentToken.Set {
			e.FieldStart("payment_token")
			s.PaymentToken.Encode(e)
		}
	}
	{
		if s.PaymentMethodID.Set {
			e.FieldStart("payment_method_id")
			s.PaymentMethodID.Encode(e)
		}
	}
	{
		if s.PaymentMethodData.Set {
			e.FieldStart("payment_method_data")
			s.PaymentMethodData.Encode(e)
		}
	}
	{
		if s.Confirmation.Set {
			e.FieldStart("confirmation")
			s.Confirmation.Encode(e)
		}
	}
	{
		if s.SavePaymentMethod.Set {
			e.FieldStart("save_payment_method")
			s.SavePaymentMethod.Encode(e)
		}
	}
	{
		if s.Capture.Set {
			e.FieldStart("capture")
			s.Capture.Encode(e)
		}
	}
	{
		if s.ClientIP.Set {
			e.FieldStart("client_ip")
			s.ClientIP.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		if s.Airline.Set {
			e.FieldStart("airline")
			s.Airline.Encode(e)
		}
	}
	{
		if s.Transfers != nil {
			e.FieldStart("transfers")
			e.ArrStart()
			for _, elem := range s.Transfers {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.MerchantCustomerID.Set {
			e.FieldStart("merchant_customer_id")
			s.MerchantCustomerID.Encode(e)
		}
	}
	{
		if s.PaymentOrder.Set {
			e.FieldStart("payment_order")
			s.PaymentOrder.Encode(e)
		}
	}
	{
		if s.Receiver.Set {
			e.FieldStart("receiver")
			s.Receiver.Encode(e)
		}
	}
	{
		if s.Statements != nil {
			e.FieldStart("statements")
			e.ArrStart()
			for _, elem := range s.Statements {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Test.Set {
			e.FieldStart("test")
			s.Test.Encode(e)
		}
	}
}

var jsonFieldsNameOfPaymentsPostReq = [20]string{
	0:  "amount",
	1:  "description",
	2:  "receipt",
	3:  "recipient",
	4:  "payment_token",
	5:  "payment_method_id",
	6:  "payment_method_data",
	7:  "confirmation",
	8:  "save_payment_method",
	9:  "capture",
	10: "client_ip",
	11: "metadata",
	12: "airline",
	13: "transfers",
	14: "deal",
	15: "merchant_customer_id",
	16: "payment_order",
	17: "receiver",
	18: "statements",
	19: "test",
}

// Decode decodes PaymentsPostReq from json.
func (s *PaymentsPostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReq to nil")
	}
	var requiredBitSet [3]uint8
	s.setDefaults()

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "receipt":
			if err := func() error {
				s.Receipt.Reset()
				if err := s.Receipt.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt\"")
			}
		case "recipient":
			if err := func() error {
				s.Recipient.Reset()
				if err := s.Recipient.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"recipient\"")
			}
		case "payment_token":
			if err := func() error {
				s.PaymentToken.Reset()
				if err := s.PaymentToken.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_token\"")
			}
		case "payment_method_id":
			if err := func() error {
				s.PaymentMethodID.Reset()
				if err := s.PaymentMethodID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_method_id\"")
			}
		case "payment_method_data":
			if err := func() error {
				s.PaymentMethodData.Reset()
				if err := s.PaymentMethodData.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_method_data\"")
			}
		case "confirmation":
			if err := func() error {
				s.Confirmation.Reset()
				if err := s.Confirmation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation\"")
			}
		case "save_payment_method":
			if err := func() error {
				s.SavePaymentMethod.Reset()
				if err := s.SavePaymentMethod.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"save_payment_method\"")
			}
		case "capture":
			if err := func() error {
				s.Capture.Reset()
				if err := s.Capture.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"capture\"")
			}
		case "client_ip":
			if err := func() error {
				s.ClientIP.Reset()
				if err := s.ClientIP.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"client_ip\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "airline":
			if err := func() error {
				s.Airline.Reset()
				if err := s.Airline.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"airline\"")
			}
		case "transfers":
			if err := func() error {
				s.Transfers = make([]TransferDataPayment, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem TransferDataPayment
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Transfers = append(s.Transfers, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"transfers\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "merchant_customer_id":
			if err := func() error {
				s.MerchantCustomerID.Reset()
				if err := s.MerchantCustomerID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"merchant_customer_id\"")
			}
		case "payment_order":
			if err := func() error {
				s.PaymentOrder.Reset()
				if err := s.PaymentOrder.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_order\"")
			}
		case "receiver":
			if err := func() error {
				s.Receiver.Reset()
				if err := s.Receiver.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receiver\"")
			}
		case "statements":
			if err := func() error {
				s.Statements = make([]PaymentsPostReqStatementsItem, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem PaymentsPostReqStatementsItem
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Statements = append(s.Statements, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"statements\"")
			}
		case "test":
			if err := func() error {
				s.Test.Reset()
				if err := s.Test.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPostReq")
	}
	// 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(jsonFieldsNameOfPaymentsPostReq) {
					name = jsonFieldsNameOfPaymentsPostReq[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 *PaymentsPostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPostReqAirline) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPostReqAirline) encodeFields(e *jx.Encoder) {
	{
		if s.TicketNumber.Set {
			e.FieldStart("ticket_number")
			s.TicketNumber.Encode(e)
		}
	}
	{
		if s.BookingReference.Set {
			e.FieldStart("booking_reference")
			s.BookingReference.Encode(e)
		}
	}
	{
		if s.Passengers != nil {
			e.FieldStart("passengers")
			e.ArrStart()
			for _, elem := range s.Passengers {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Legs != nil {
			e.FieldStart("legs")
			e.ArrStart()
			for _, elem := range s.Legs {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
}

var jsonFieldsNameOfPaymentsPostReqAirline = [4]string{
	0: "ticket_number",
	1: "booking_reference",
	2: "passengers",
	3: "legs",
}

// Decode decodes PaymentsPostReqAirline from json.
func (s *PaymentsPostReqAirline) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqAirline to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "ticket_number":
			if err := func() error {
				s.TicketNumber.Reset()
				if err := s.TicketNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"ticket_number\"")
			}
		case "booking_reference":
			if err := func() error {
				s.BookingReference.Reset()
				if err := s.BookingReference.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"booking_reference\"")
			}
		case "passengers":
			if err := func() error {
				s.Passengers = make([]AirlinePassenger, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem AirlinePassenger
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Passengers = append(s.Passengers, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"passengers\"")
			}
		case "legs":
			if err := func() error {
				s.Legs = make([]AirlineLeg, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem AirlineLeg
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Legs = append(s.Legs, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"legs\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPostReqAirline")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PaymentsPostReqAirline) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqAirline) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPostReqAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPostReqAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPaymentsPostReqAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PaymentsPostReqAmount from json.
func (s *PaymentsPostReqAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPostReqAmount")
	}
	// 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(jsonFieldsNameOfPaymentsPostReqAmount) {
					name = jsonFieldsNameOfPaymentsPostReqAmount[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 *PaymentsPostReqAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentsPostReqConfirmation as json.
func (s PaymentsPostReqConfirmation) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentsPostReqConfirmation) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case ConfirmationDataRedirectPaymentsPostReqConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationDataRedirect")
		{
			s := s.ConfirmationDataRedirect
			{
				if s.Locale.Set {
					e.FieldStart("locale")
					s.Locale.Encode(e)
				}
			}
			{
				if s.Enforce.Set {
					e.FieldStart("enforce")
					s.Enforce.Encode(e)
				}
			}
			{
				e.FieldStart("return_url")
				s.ReturnURL.Encode(e)
			}
		}
	case ConfirmationDataExternalPaymentsPostReqConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationDataExternal")
		{
			s := s.ConfirmationDataExternal
			{
				if s.Locale.Set {
					e.FieldStart("locale")
					s.Locale.Encode(e)
				}
			}
		}
	case ConfirmationDataQrPaymentsPostReqConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationDataQr")
		{
			s := s.ConfirmationDataQr
			{
				if s.Locale.Set {
					e.FieldStart("locale")
					s.Locale.Encode(e)
				}
			}
			{
				if s.ReturnURL.Set {
					e.FieldStart("return_url")
					s.ReturnURL.Encode(e)
				}
			}
		}
	case ConfirmationDataEmbeddedPaymentsPostReqConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationDataEmbedded")
		{
			s := s.ConfirmationDataEmbedded
			{
				if s.Locale.Set {
					e.FieldStart("locale")
					s.Locale.Encode(e)
				}
			}
		}
	case ConfirmationDataMobileApplicationPaymentsPostReqConfirmation:
		e.FieldStart("type")
		e.Str("ConfirmationDataMobileApplication")
		{
			s := s.ConfirmationDataMobileApplication
			{
				if s.Locale.Set {
					e.FieldStart("locale")
					s.Locale.Encode(e)
				}
			}
			{
				e.FieldStart("return_url")
				e.Str(s.ReturnURL)
			}
		}
	}
}

// Decode decodes PaymentsPostReqConfirmation from json.
func (s *PaymentsPostReqConfirmation) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqConfirmation to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "ConfirmationDataRedirect":
					s.Type = ConfirmationDataRedirectPaymentsPostReqConfirmation
					found = true
				case "ConfirmationDataExternal":
					s.Type = ConfirmationDataExternalPaymentsPostReqConfirmation
					found = true
				case "ConfirmationDataQr":
					s.Type = ConfirmationDataQrPaymentsPostReqConfirmation
					found = true
				case "ConfirmationDataEmbedded":
					s.Type = ConfirmationDataEmbeddedPaymentsPostReqConfirmation
					found = true
				case "ConfirmationDataMobileApplication":
					s.Type = ConfirmationDataMobileApplicationPaymentsPostReqConfirmation
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case ConfirmationDataRedirectPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataRedirect.Decode(d); err != nil {
			return err
		}
	case ConfirmationDataExternalPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataExternal.Decode(d); err != nil {
			return err
		}
	case ConfirmationDataQrPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataQr.Decode(d); err != nil {
			return err
		}
	case ConfirmationDataEmbeddedPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataEmbedded.Decode(d); err != nil {
			return err
		}
	case ConfirmationDataMobileApplicationPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataMobileApplication.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentsPostReqConfirmation) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqConfirmation) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PaymentsPostReqDeal) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PaymentsPostReqDeal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("settlements")
		s.Settlements.Encode(e)
	}
}

var jsonFieldsNameOfPaymentsPostReqDeal = [2]string{
	0: "id",
	1: "settlements",
}

// Decode decodes PaymentsPostReqDeal from json.
func (s *PaymentsPostReqDeal) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqDeal 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "settlements":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Settlements.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"settlements\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PaymentsPostReqDeal")
	}
	// 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(jsonFieldsNameOfPaymentsPostReqDeal) {
					name = jsonFieldsNameOfPaymentsPostReqDeal[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 *PaymentsPostReqDeal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqDeal) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentsPostReqPaymentMethodData as json.
func (s PaymentsPostReqPaymentMethodData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentsPostReqPaymentMethodData) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PaymentMethodDataBankCardPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataBankCard")
		{
			s := s.PaymentMethodDataBankCard
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	case PaymentMethodDataCashPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataCash")
		{
			s := s.PaymentMethodDataCash
			{
				if s.Phone.Set {
					e.FieldStart("phone")
					s.Phone.Encode(e)
				}
			}
		}
	case PaymentMethodDataSberbankPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataSberbank")
		{
			s := s.PaymentMethodDataSberbank
			{
				if s.Phone.Set {
					e.FieldStart("phone")
					s.Phone.Encode(e)
				}
			}
		}
	case PaymentMethodDataTinkoffBankPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataTinkoffBank")
	case PaymentMethodDataYooMoneyPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataYooMoney")
	case PaymentMethodDataMobileBalancePaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataMobileBalance")
		{
			s := s.PaymentMethodDataMobileBalance
			{
				e.FieldStart("phone")
				e.Str(s.Phone)
			}
		}
	case PaymentMethodDataB2bSberbankPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataB2bSberbank")
		{
			s := s.PaymentMethodDataB2bSberbank
			{
				e.FieldStart("payment_purpose")
				s.PaymentPurpose.Encode(e)
			}
			{
				e.FieldStart("vat_data")
				s.VatData.Encode(e)
			}
		}
	case PaymentMethodDataSbpPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataSbp")
	case PaymentMethodDataSberLoanPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataSberLoan")
	case PaymentMethodDataElectronicCertificatePaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataElectronicCertificate")
		{
			s := s.PaymentMethodDataElectronicCertificate
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
			{
				if s.ElectronicCertificate.Set {
					e.FieldStart("electronic_certificate")
					s.ElectronicCertificate.Encode(e)
				}
			}
			{
				if s.Articles != nil {
					e.FieldStart("articles")
					e.ArrStart()
					for _, elem := range s.Articles {
						elem.Encode(e)
					}
					e.ArrEnd()
				}
			}
		}
	case PaymentMethodDataSberBnplPaymentsPostReqPaymentMethodData:
		e.FieldStart("type")
		e.Str("PaymentMethodDataSberBnpl")
		{
			s := s.PaymentMethodDataSberBnpl
			{
				if s.Phone.Set {
					e.FieldStart("phone")
					s.Phone.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentsPostReqPaymentMethodData from json.
func (s *PaymentsPostReqPaymentMethodData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqPaymentMethodData to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "PaymentMethodDataBankCard":
					s.Type = PaymentMethodDataBankCardPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataCash":
					s.Type = PaymentMethodDataCashPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataSberbank":
					s.Type = PaymentMethodDataSberbankPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataTinkoffBank":
					s.Type = PaymentMethodDataTinkoffBankPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataYooMoney":
					s.Type = PaymentMethodDataYooMoneyPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataMobileBalance":
					s.Type = PaymentMethodDataMobileBalancePaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataB2bSberbank":
					s.Type = PaymentMethodDataB2bSberbankPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataSbp":
					s.Type = PaymentMethodDataSbpPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataSberLoan":
					s.Type = PaymentMethodDataSberLoanPaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataElectronicCertificate":
					s.Type = PaymentMethodDataElectronicCertificatePaymentsPostReqPaymentMethodData
					found = true
				case "PaymentMethodDataSberBnpl":
					s.Type = PaymentMethodDataSberBnplPaymentsPostReqPaymentMethodData
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PaymentMethodDataBankCardPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataBankCard.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataCashPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataCash.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataSberbankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberbank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataTinkoffBankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataTinkoffBank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataYooMoneyPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataYooMoney.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataMobileBalancePaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataMobileBalance.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataB2bSberbankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataB2bSberbank.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataSbpPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSbp.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataSberLoanPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberLoan.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataElectronicCertificatePaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataElectronicCertificate.Decode(d); err != nil {
			return err
		}
	case PaymentMethodDataSberBnplPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberBnpl.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentsPostReqPaymentMethodData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqPaymentMethodData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentsPostReqPaymentOrder as json.
func (s PaymentsPostReqPaymentOrder) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentsPostReqPaymentOrder) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PaymentOrderDataUtilitiesPaymentsPostReqPaymentOrder:
		e.FieldStart("type")
		e.Str("PaymentOrderDataUtilities")
		{
			s := s.PaymentOrderDataUtilities
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
			{
				e.FieldStart("payment_purpose")
				e.Str(s.PaymentPurpose)
			}
			{
				e.FieldStart("recipient")
				s.Recipient.Encode(e)
			}
			{
				if s.Kbk.Set {
					e.FieldStart("kbk")
					s.Kbk.Encode(e)
				}
			}
			{
				if s.Oktmo.Set {
					e.FieldStart("oktmo")
					s.Oktmo.Encode(e)
				}
			}
			{
				if s.PaymentPeriod.Set {
					e.FieldStart("payment_period")
					s.PaymentPeriod.Encode(e)
				}
			}
			{
				if s.PaymentDocumentID.Set {
					e.FieldStart("payment_document_id")
					s.PaymentDocumentID.Encode(e)
				}
			}
			{
				if s.PaymentDocumentNumber.Set {
					e.FieldStart("payment_document_number")
					s.PaymentDocumentNumber.Encode(e)
				}
			}
			{
				if s.AccountNumber.Set {
					e.FieldStart("account_number")
					s.AccountNumber.Encode(e)
				}
			}
			{
				if s.UnifiedAccountNumber.Set {
					e.FieldStart("unified_account_number")
					s.UnifiedAccountNumber.Encode(e)
				}
			}
			{
				if s.ServiceID.Set {
					e.FieldStart("service_id")
					s.ServiceID.Encode(e)
				}
			}
		}
	}
}

// Decode decodes PaymentsPostReqPaymentOrder from json.
func (s *PaymentsPostReqPaymentOrder) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqPaymentOrder to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "PaymentOrderDataUtilities":
					s.Type = PaymentOrderDataUtilitiesPaymentsPostReqPaymentOrder
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PaymentOrderDataUtilitiesPaymentsPostReqPaymentOrder:
		if err := s.PaymentOrderDataUtilities.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentsPostReqPaymentOrder) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqPaymentOrder) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentsPostReqReceiver as json.
func (s PaymentsPostReqReceiver) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentsPostReqReceiver) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case ReceiverMobileBalancePaymentsPostReqReceiver:
		e.FieldStart("type")
		e.Str("ReceiverMobileBalance")
		{
			s := s.ReceiverMobileBalance
			{
				e.FieldStart("phone")
				e.Str(s.Phone)
			}
		}
	case ReceiverDigitalWalletPaymentsPostReqReceiver:
		e.FieldStart("type")
		e.Str("ReceiverDigitalWallet")
		{
			s := s.ReceiverDigitalWallet
			{
				e.FieldStart("account_number")
				e.Str(s.AccountNumber)
			}
		}
	case ReceiverBankAccountPaymentsPostReqReceiver:
		e.FieldStart("type")
		e.Str("ReceiverBankAccount")
		{
			s := s.ReceiverBankAccount
			{
				e.FieldStart("account_number")
				e.Str(s.AccountNumber)
			}
			{
				e.FieldStart("bic")
				e.Str(s.Bic)
			}
		}
	}
}

// Decode decodes PaymentsPostReqReceiver from json.
func (s *PaymentsPostReqReceiver) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqReceiver to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "ReceiverMobileBalance":
					s.Type = ReceiverMobileBalancePaymentsPostReqReceiver
					found = true
				case "ReceiverDigitalWallet":
					s.Type = ReceiverDigitalWalletPaymentsPostReqReceiver
					found = true
				case "ReceiverBankAccount":
					s.Type = ReceiverBankAccountPaymentsPostReqReceiver
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case ReceiverMobileBalancePaymentsPostReqReceiver:
		if err := s.ReceiverMobileBalance.Decode(d); err != nil {
			return err
		}
	case ReceiverDigitalWalletPaymentsPostReqReceiver:
		if err := s.ReceiverDigitalWallet.Decode(d); err != nil {
			return err
		}
	case ReceiverBankAccountPaymentsPostReqReceiver:
		if err := s.ReceiverBankAccount.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentsPostReqReceiver) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqReceiver) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PaymentsPostReqStatementsItem as json.
func (s PaymentsPostReqStatementsItem) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PaymentsPostReqStatementsItem) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PaymentOverviewStatementDataPaymentsPostReqStatementsItem:
		e.FieldStart("type")
		e.Str("PaymentOverviewStatementData")
		{
			s := s.PaymentOverviewStatementData
			{
				e.FieldStart("delivery_method")
				s.DeliveryMethod.Encode(e)
			}
		}
	}
}

// Decode decodes PaymentsPostReqStatementsItem from json.
func (s *PaymentsPostReqStatementsItem) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PaymentsPostReqStatementsItem to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "PaymentOverviewStatementData":
					s.Type = PaymentOverviewStatementDataPaymentsPostReqStatementsItem
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PaymentOverviewStatementDataPaymentsPostReqStatementsItem:
		if err := s.PaymentOverviewStatementData.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PaymentsPostReqStatementsItem) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PaymentsPostReqStatementsItem) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Payout) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Payout) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		e.FieldStart("payout_destination")
		s.PayoutDestination.Encode(e)
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
	{
		if s.SucceededAt.Set {
			e.FieldStart("succeeded_at")
			s.SucceededAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.SelfEmployed.Set {
			e.FieldStart("self_employed")
			s.SelfEmployed.Encode(e)
		}
	}
	{
		if s.Receipt.Set {
			e.FieldStart("receipt")
			s.Receipt.Encode(e)
		}
	}
	{
		if s.CancellationDetails.Set {
			e.FieldStart("cancellation_details")
			s.CancellationDetails.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		e.FieldStart("test")
		s.Test.Encode(e)
	}
}

var jsonFieldsNameOfPayout = [13]string{
	0:  "id",
	1:  "amount",
	2:  "status",
	3:  "payout_destination",
	4:  "description",
	5:  "created_at",
	6:  "succeeded_at",
	7:  "deal",
	8:  "self_employed",
	9:  "receipt",
	10: "cancellation_details",
	11: "metadata",
	12: "test",
}

// Decode decodes Payout from json.
func (s *Payout) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Payout 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "payout_destination":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.PayoutDestination.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_destination\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "succeeded_at":
			if err := func() error {
				s.SucceededAt.Reset()
				if err := s.SucceededAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"succeeded_at\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "self_employed":
			if err := func() error {
				s.SelfEmployed.Reset()
				if err := s.SelfEmployed.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"self_employed\"")
			}
		case "receipt":
			if err := func() error {
				s.Receipt.Reset()
				if err := s.Receipt.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt\"")
			}
		case "cancellation_details":
			if err := func() error {
				s.CancellationDetails.Reset()
				if err := s.CancellationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cancellation_details\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "test":
			requiredBitSet[1] |= 1 << 4
			if err := func() error {
				if err := s.Test.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Payout")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00101111,
		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(jsonFieldsNameOfPayout) {
					name = jsonFieldsNameOfPayout[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 *Payout) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Payout) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPayoutAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PayoutAmount from json.
func (s *PayoutAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutAmount")
	}
	// 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(jsonFieldsNameOfPayoutAmount) {
					name = jsonFieldsNameOfPayoutAmount[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 *PayoutAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutCancellationDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutCancellationDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("party")
		s.Party.Encode(e)
	}
	{
		e.FieldStart("reason")
		s.Reason.Encode(e)
	}
}

var jsonFieldsNameOfPayoutCancellationDetails = [2]string{
	0: "party",
	1: "reason",
}

// Decode decodes PayoutCancellationDetails from json.
func (s *PayoutCancellationDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutCancellationDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "party":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Party.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"party\"")
			}
		case "reason":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Reason.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"reason\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutCancellationDetails")
	}
	// 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(jsonFieldsNameOfPayoutCancellationDetails) {
					name = jsonFieldsNameOfPayoutCancellationDetails[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 *PayoutCancellationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutCancellationDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutCancellationDetailsParty as json.
func (s PayoutCancellationDetailsParty) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutCancellationDetailsParty from json.
func (s *PayoutCancellationDetailsParty) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutCancellationDetailsParty to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutCancellationDetailsParty(v) {
	case PayoutCancellationDetailsPartyYooMoney:
		*s = PayoutCancellationDetailsPartyYooMoney
	case PayoutCancellationDetailsPartyPayoutNetwork:
		*s = PayoutCancellationDetailsPartyPayoutNetwork
	default:
		*s = PayoutCancellationDetailsParty(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutCancellationDetailsParty) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutCancellationDetailsParty) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutCancellationDetailsReason as json.
func (s PayoutCancellationDetailsReason) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutCancellationDetailsReason from json.
func (s *PayoutCancellationDetailsReason) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutCancellationDetailsReason to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutCancellationDetailsReason(v) {
	case PayoutCancellationDetailsReasonInsufficientFunds:
		*s = PayoutCancellationDetailsReasonInsufficientFunds
	case PayoutCancellationDetailsReasonFraudSuspected:
		*s = PayoutCancellationDetailsReasonFraudSuspected
	case PayoutCancellationDetailsReasonOneTimeLimitExceeded:
		*s = PayoutCancellationDetailsReasonOneTimeLimitExceeded
	case PayoutCancellationDetailsReasonPeriodicLimitExceeded:
		*s = PayoutCancellationDetailsReasonPeriodicLimitExceeded
	case PayoutCancellationDetailsReasonRejectedByPayee:
		*s = PayoutCancellationDetailsReasonRejectedByPayee
	case PayoutCancellationDetailsReasonGeneralDecline:
		*s = PayoutCancellationDetailsReasonGeneralDecline
	case PayoutCancellationDetailsReasonIssuerUnavailable:
		*s = PayoutCancellationDetailsReasonIssuerUnavailable
	case PayoutCancellationDetailsReasonRecipientNotFound:
		*s = PayoutCancellationDetailsReasonRecipientNotFound
	case PayoutCancellationDetailsReasonRecipientCheckFailed:
		*s = PayoutCancellationDetailsReasonRecipientCheckFailed
	case PayoutCancellationDetailsReasonIdentificationRequired:
		*s = PayoutCancellationDetailsReasonIdentificationRequired
	case PayoutCancellationDetailsReasonSelfEmployedAnnualLimitExceeded:
		*s = PayoutCancellationDetailsReasonSelfEmployedAnnualLimitExceeded
	default:
		*s = PayoutCancellationDetailsReason(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutCancellationDetailsReason) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutCancellationDetailsReason) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutCardData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutCardData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("first6")
		e.Str(s.First6)
	}
	{
		e.FieldStart("last4")
		s.Last4.Encode(e)
	}
	{
		e.FieldStart("card_type")
		s.CardType.Encode(e)
	}
	{
		if s.IssuerCountry.Set {
			e.FieldStart("issuer_country")
			s.IssuerCountry.Encode(e)
		}
	}
	{
		if s.IssuerName.Set {
			e.FieldStart("issuer_name")
			s.IssuerName.Encode(e)
		}
	}
}

var jsonFieldsNameOfPayoutCardData = [5]string{
	0: "first6",
	1: "last4",
	2: "card_type",
	3: "issuer_country",
	4: "issuer_name",
}

// Decode decodes PayoutCardData from json.
func (s *PayoutCardData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutCardData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "first6":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.First6 = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first6\"")
			}
		case "last4":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Last4.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last4\"")
			}
		case "card_type":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.CardType.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"card_type\"")
			}
		case "issuer_country":
			if err := func() error {
				s.IssuerCountry.Reset()
				if err := s.IssuerCountry.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_country\"")
			}
		case "issuer_name":
			if err := func() error {
				s.IssuerName.Reset()
				if err := s.IssuerName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"issuer_name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutCardData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfPayoutCardData) {
					name = jsonFieldsNameOfPayoutCardData[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 *PayoutCardData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutCardData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutDeal) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutDeal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
}

var jsonFieldsNameOfPayoutDeal = [1]string{
	0: "id",
}

// Decode decodes PayoutDeal from json.
func (s *PayoutDeal) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutDeal 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutDeal")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPayoutDeal) {
					name = jsonFieldsNameOfPayoutDeal[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 *PayoutDeal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutDeal) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutDealInfo) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutDealInfo) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
}

var jsonFieldsNameOfPayoutDealInfo = [1]string{
	0: "id",
}

// Decode decodes PayoutDealInfo from json.
func (s *PayoutDealInfo) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutDealInfo 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutDealInfo")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPayoutDealInfo) {
					name = jsonFieldsNameOfPayoutDealInfo[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 *PayoutDealInfo) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutDealInfo) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutDestinationDataType as json.
func (s PayoutDestinationDataType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutDestinationDataType from json.
func (s *PayoutDestinationDataType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutDestinationDataType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutDestinationDataType(v) {
	case PayoutDestinationDataTypeYooMoney:
		*s = PayoutDestinationDataTypeYooMoney
	case PayoutDestinationDataTypeBankCard:
		*s = PayoutDestinationDataTypeBankCard
	case PayoutDestinationDataTypeSbp:
		*s = PayoutDestinationDataTypeSbp
	default:
		*s = PayoutDestinationDataType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutDestinationDataType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutDestinationDataType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutDestinationType as json.
func (s PayoutDestinationType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutDestinationType from json.
func (s *PayoutDestinationType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutDestinationType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutDestinationType(v) {
	case PayoutDestinationTypeBankCard:
		*s = PayoutDestinationTypeBankCard
	case PayoutDestinationTypeYooMoney:
		*s = PayoutDestinationTypeYooMoney
	case PayoutDestinationTypeSbp:
		*s = PayoutDestinationTypeSbp
	default:
		*s = PayoutDestinationType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutDestinationType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutDestinationType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutId as json.
func (s PayoutId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PayoutId from json.
func (s *PayoutId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutMethodType as json.
func (s PayoutMethodType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutMethodType from json.
func (s *PayoutMethodType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutMethodType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutMethodType(v) {
	case PayoutMethodTypeBankCard:
		*s = PayoutMethodTypeBankCard
	case PayoutMethodTypeYooMoney:
		*s = PayoutMethodTypeYooMoney
	case PayoutMethodTypeSbp:
		*s = PayoutMethodTypeSbp
	default:
		*s = PayoutMethodType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutMethodType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutMethodType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutPayoutDestination as json.
func (s PayoutPayoutDestination) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PayoutPayoutDestination) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PayoutToCardDestinationPayoutPayoutDestination:
		e.FieldStart("type")
		e.Str("PayoutToCardDestination")
		{
			s := s.PayoutToCardDestination
			{
				if s.Card.Set {
					e.FieldStart("card")
					s.Card.Encode(e)
				}
			}
		}
	case PayoutToYooMoneyDestinationPayoutPayoutDestination:
		e.FieldStart("type")
		e.Str("PayoutToYooMoneyDestination")
		{
			s := s.PayoutToYooMoneyDestination
			{
				e.FieldStart("account_number")
				s.AccountNumber.Encode(e)
			}
		}
	case PayoutToSbpDestinationPayoutPayoutDestination:
		e.FieldStart("type")
		e.Str("PayoutToSbpDestination")
		{
			s := s.PayoutToSbpDestination
			{
				e.FieldStart("phone")
				e.Str(s.Phone)
			}
			{
				e.FieldStart("bank_id")
				e.Str(s.BankID)
			}
			{
				e.FieldStart("recipient_checked")
				e.Bool(s.RecipientChecked)
			}
		}
	}
}

// Decode decodes PayoutPayoutDestination from json.
func (s *PayoutPayoutDestination) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutPayoutDestination to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "PayoutToCardDestination":
					s.Type = PayoutToCardDestinationPayoutPayoutDestination
					found = true
				case "PayoutToYooMoneyDestination":
					s.Type = PayoutToYooMoneyDestinationPayoutPayoutDestination
					found = true
				case "PayoutToSbpDestination":
					s.Type = PayoutToSbpDestinationPayoutPayoutDestination
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PayoutToCardDestinationPayoutPayoutDestination:
		if err := s.PayoutToCardDestination.Decode(d); err != nil {
			return err
		}
	case PayoutToYooMoneyDestinationPayoutPayoutDestination:
		if err := s.PayoutToYooMoneyDestination.Decode(d); err != nil {
			return err
		}
	case PayoutToSbpDestinationPayoutPayoutDestination:
		if err := s.PayoutToSbpDestination.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutPayoutDestination) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutPayoutDestination) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutRequest) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutRequest) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.PayoutDestinationData.Set {
			e.FieldStart("payout_destination_data")
			s.PayoutDestinationData.Encode(e)
		}
	}
	{
		if s.PayoutToken.Set {
			e.FieldStart("payout_token")
			s.PayoutToken.Encode(e)
		}
	}
	{
		if s.PaymentMethodID.Set {
			e.FieldStart("payment_method_id")
			s.PaymentMethodID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.PersonalData != nil {
			e.FieldStart("personal_data")
			e.ArrStart()
			for _, elem := range s.PersonalData {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		if s.Test.Set {
			e.FieldStart("test")
			s.Test.Encode(e)
		}
	}
}

var jsonFieldsNameOfPayoutRequest = [9]string{
	0: "amount",
	1: "payout_destination_data",
	2: "payout_token",
	3: "payment_method_id",
	4: "description",
	5: "deal",
	6: "personal_data",
	7: "metadata",
	8: "test",
}

// Decode decodes PayoutRequest from json.
func (s *PayoutRequest) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutRequest to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "amount":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "payout_destination_data":
			if err := func() error {
				s.PayoutDestinationData.Reset()
				if err := s.PayoutDestinationData.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_destination_data\"")
			}
		case "payout_token":
			if err := func() error {
				s.PayoutToken.Reset()
				if err := s.PayoutToken.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_token\"")
			}
		case "payment_method_id":
			if err := func() error {
				s.PaymentMethodID.Reset()
				if err := s.PaymentMethodID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_method_id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "personal_data":
			if err := func() error {
				s.PersonalData = make([]PayoutsPersonalData, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem PayoutsPersonalData
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.PersonalData = append(s.PersonalData, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"personal_data\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "test":
			if err := func() error {
				s.Test.Reset()
				if err := s.Test.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutRequest")
	}
	// 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(jsonFieldsNameOfPayoutRequest) {
					name = jsonFieldsNameOfPayoutRequest[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 *PayoutRequest) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutRequest) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutRequestAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutRequestAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfPayoutRequestAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes PayoutRequestAmount from json.
func (s *PayoutRequestAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutRequestAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutRequestAmount")
	}
	// 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(jsonFieldsNameOfPayoutRequestAmount) {
					name = jsonFieldsNameOfPayoutRequestAmount[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 *PayoutRequestAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutRequestAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutRequestPayoutDestinationData as json.
func (s PayoutRequestPayoutDestinationData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PayoutRequestPayoutDestinationData) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case YooMoneyPayoutRequestPayoutDestinationData:
		e.FieldStart("type")
		e.Str("yoo_money")
		{
			s := s.YooMoney
			{
				e.FieldStart("account_number")
				e.Str(s.AccountNumber)
			}
		}
	case BankCardPayoutRequestPayoutDestinationData:
		e.FieldStart("type")
		e.Str("bank_card")
		{
			s := s.BankCard
			{
				e.FieldStart("card")
				s.Card.Encode(e)
			}
		}
	case SbpPayoutRequestPayoutDestinationData:
		e.FieldStart("type")
		e.Str("sbp")
		{
			s := s.Sbp
			{
				e.FieldStart("phone")
				e.Str(s.Phone)
			}
			{
				e.FieldStart("bank_id")
				e.Str(s.BankID)
			}
		}
	}
}

// Decode decodes PayoutRequestPayoutDestinationData from json.
func (s *PayoutRequestPayoutDestinationData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutRequestPayoutDestinationData to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "yoo_money":
					s.Type = YooMoneyPayoutRequestPayoutDestinationData
					found = true
				case "bank_card":
					s.Type = BankCardPayoutRequestPayoutDestinationData
					found = true
				case "sbp":
					s.Type = SbpPayoutRequestPayoutDestinationData
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case YooMoneyPayoutRequestPayoutDestinationData:
		if err := s.YooMoney.Decode(d); err != nil {
			return err
		}
	case BankCardPayoutRequestPayoutDestinationData:
		if err := s.BankCard.Decode(d); err != nil {
			return err
		}
	case SbpPayoutRequestPayoutDestinationData:
		if err := s.Sbp.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutRequestPayoutDestinationData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutRequestPayoutDestinationData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutSelfEmployed) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutSelfEmployed) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
}

var jsonFieldsNameOfPayoutSelfEmployed = [1]string{
	0: "id",
}

// Decode decodes PayoutSelfEmployed from json.
func (s *PayoutSelfEmployed) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutSelfEmployed 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutSelfEmployed")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPayoutSelfEmployed) {
					name = jsonFieldsNameOfPayoutSelfEmployed[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 *PayoutSelfEmployed) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutSelfEmployed) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutStatementRecipientPersonalDataRequest) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutStatementRecipientPersonalDataRequest) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		e.FieldStart("last_name")
		s.LastName.Encode(e)
	}
	{
		e.FieldStart("first_name")
		s.FirstName.Encode(e)
	}
	{
		if s.MiddleName.Set {
			e.FieldStart("middle_name")
			s.MiddleName.Encode(e)
		}
	}
	{
		e.FieldStart("birthdate")
		json.EncodeDate(e, s.Birthdate)
	}
}

var jsonFieldsNameOfPayoutStatementRecipientPersonalDataRequest = [6]string{
	0: "type",
	1: "metadata",
	2: "last_name",
	3: "first_name",
	4: "middle_name",
	5: "birthdate",
}

// Decode decodes PayoutStatementRecipientPersonalDataRequest from json.
func (s *PayoutStatementRecipientPersonalDataRequest) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutStatementRecipientPersonalDataRequest to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "last_name":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.LastName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last_name\"")
			}
		case "first_name":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.FirstName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first_name\"")
			}
		case "middle_name":
			if err := func() error {
				s.MiddleName.Reset()
				if err := s.MiddleName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"middle_name\"")
			}
		case "birthdate":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				v, err := json.DecodeDate(d)
				s.Birthdate = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"birthdate\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutStatementRecipientPersonalDataRequest")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00101101,
	} {
		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(jsonFieldsNameOfPayoutStatementRecipientPersonalDataRequest) {
					name = jsonFieldsNameOfPayoutStatementRecipientPersonalDataRequest[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 *PayoutStatementRecipientPersonalDataRequest) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutStatementRecipientPersonalDataRequest) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutStatus as json.
func (s PayoutStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutStatus from json.
func (s *PayoutStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutStatus(v) {
	case PayoutStatusPending:
		*s = PayoutStatusPending
	case PayoutStatusSucceeded:
		*s = PayoutStatusSucceeded
	case PayoutStatusCanceled:
		*s = PayoutStatusCanceled
	default:
		*s = PayoutStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutToCardDestination) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutToCardDestination) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfPayoutToCardDestination = [2]string{
	0: "type",
	1: "card",
}

// Decode decodes PayoutToCardDestination from json.
func (s *PayoutToCardDestination) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutToCardDestination to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutToCardDestination")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPayoutToCardDestination) {
					name = jsonFieldsNameOfPayoutToCardDestination[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 *PayoutToCardDestination) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutToCardDestination) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutToSbpDestination) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutToSbpDestination) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("phone")
		e.Str(s.Phone)
	}
	{
		e.FieldStart("bank_id")
		e.Str(s.BankID)
	}
	{
		e.FieldStart("recipient_checked")
		e.Bool(s.RecipientChecked)
	}
}

var jsonFieldsNameOfPayoutToSbpDestination = [4]string{
	0: "type",
	1: "phone",
	2: "bank_id",
	3: "recipient_checked",
}

// Decode decodes PayoutToSbpDestination from json.
func (s *PayoutToSbpDestination) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutToSbpDestination to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Phone = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		case "bank_id":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.BankID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_id\"")
			}
		case "recipient_checked":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Bool()
				s.RecipientChecked = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"recipient_checked\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutToSbpDestination")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001111,
	} {
		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(jsonFieldsNameOfPayoutToSbpDestination) {
					name = jsonFieldsNameOfPayoutToSbpDestination[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 *PayoutToSbpDestination) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutToSbpDestination) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutToYooMoneyDestination) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutToYooMoneyDestination) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("account_number")
		s.AccountNumber.Encode(e)
	}
}

var jsonFieldsNameOfPayoutToYooMoneyDestination = [2]string{
	0: "type",
	1: "account_number",
}

// Decode decodes PayoutToYooMoneyDestination from json.
func (s *PayoutToYooMoneyDestination) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutToYooMoneyDestination to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "account_number":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.AccountNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutToYooMoneyDestination")
	}
	// 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(jsonFieldsNameOfPayoutToYooMoneyDestination) {
					name = jsonFieldsNameOfPayoutToYooMoneyDestination[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 *PayoutToYooMoneyDestination) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutToYooMoneyDestination) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsGetInternalServerError as json.
func (s *PayoutsGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsGetInternalServerError from json.
func (s *PayoutsGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsGetTooManyRequests as json.
func (s *PayoutsGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsGetTooManyRequests from json.
func (s *PayoutsGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutsList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutsList) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.NextCursor.Set {
			e.FieldStart("next_cursor")
			s.NextCursor.Encode(e)
		}
	}
}

var jsonFieldsNameOfPayoutsList = [3]string{
	0: "type",
	1: "items",
	2: "next_cursor",
}

// Decode decodes PayoutsList from json.
func (s *PayoutsList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsList to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]Payout, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Payout
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "next_cursor":
			if err := func() error {
				s.NextCursor.Reset()
				if err := s.NextCursor.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next_cursor\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutsList")
	}
	// 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(jsonFieldsNameOfPayoutsList) {
					name = jsonFieldsNameOfPayoutsList[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 *PayoutsList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsListType as json.
func (s PayoutsListType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PayoutsListType from json.
func (s *PayoutsListType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsListType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PayoutsListType(v) {
	case PayoutsListTypeList:
		*s = PayoutsListTypeList
	default:
		*s = PayoutsListType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PayoutsListType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsListType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsPayoutIDGetInternalServerError as json.
func (s *PayoutsPayoutIDGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsPayoutIDGetInternalServerError from json.
func (s *PayoutsPayoutIDGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsPayoutIDGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsPayoutIDGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsPayoutIDGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsPayoutIDGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsPayoutIDGetTooManyRequests as json.
func (s *PayoutsPayoutIDGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsPayoutIDGetTooManyRequests from json.
func (s *PayoutsPayoutIDGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsPayoutIDGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsPayoutIDGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsPayoutIDGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsPayoutIDGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PayoutsPersonalData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PayoutsPersonalData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
}

var jsonFieldsNameOfPayoutsPersonalData = [1]string{
	0: "id",
}

// Decode decodes PayoutsPersonalData from json.
func (s *PayoutsPersonalData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsPersonalData 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PayoutsPersonalData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfPayoutsPersonalData) {
					name = jsonFieldsNameOfPayoutsPersonalData[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 *PayoutsPersonalData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsPersonalData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsPostInternalServerError as json.
func (s *PayoutsPostInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsPostInternalServerError from json.
func (s *PayoutsPostInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsPostInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsPostInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsPostInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsPostInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsPostTooManyRequests as json.
func (s *PayoutsPostTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsPostTooManyRequests from json.
func (s *PayoutsPostTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsPostTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsPostTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsPostTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsPostTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsSearchGetInternalServerError as json.
func (s *PayoutsSearchGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsSearchGetInternalServerError from json.
func (s *PayoutsSearchGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsSearchGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsSearchGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsSearchGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsSearchGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PayoutsSearchGetTooManyRequests as json.
func (s *PayoutsSearchGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PayoutsSearchGetTooManyRequests from json.
func (s *PayoutsSearchGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PayoutsSearchGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PayoutsSearchGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PayoutsSearchGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PayoutsSearchGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PersonalData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PersonalData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.CancellationDetails.Set {
			e.FieldStart("cancellation_details")
			s.CancellationDetails.Encode(e)
		}
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
	{
		if s.ExpiresAt.Set {
			e.FieldStart("expires_at")
			s.ExpiresAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfPersonalData = [7]string{
	0: "id",
	1: "type",
	2: "status",
	3: "cancellation_details",
	4: "created_at",
	5: "expires_at",
	6: "metadata",
}

// Decode decodes PersonalData from json.
func (s *PersonalData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalData 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "type":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cancellation_details":
			if err := func() error {
				s.CancellationDetails.Reset()
				if err := s.CancellationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cancellation_details\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "expires_at":
			if err := func() error {
				s.ExpiresAt.Reset()
				if err := s.ExpiresAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expires_at\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PersonalData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00010111,
	} {
		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(jsonFieldsNameOfPersonalData) {
					name = jsonFieldsNameOfPersonalData[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 *PersonalData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *PersonalDataCancellationDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *PersonalDataCancellationDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("party")
		s.Party.Encode(e)
	}
	{
		e.FieldStart("reason")
		s.Reason.Encode(e)
	}
}

var jsonFieldsNameOfPersonalDataCancellationDetails = [2]string{
	0: "party",
	1: "reason",
}

// Decode decodes PersonalDataCancellationDetails from json.
func (s *PersonalDataCancellationDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataCancellationDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "party":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Party.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"party\"")
			}
		case "reason":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Reason.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"reason\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode PersonalDataCancellationDetails")
	}
	// 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(jsonFieldsNameOfPersonalDataCancellationDetails) {
					name = jsonFieldsNameOfPersonalDataCancellationDetails[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 *PersonalDataCancellationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataCancellationDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataCancellationDetailsParty as json.
func (s PersonalDataCancellationDetailsParty) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PersonalDataCancellationDetailsParty from json.
func (s *PersonalDataCancellationDetailsParty) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataCancellationDetailsParty to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PersonalDataCancellationDetailsParty(v) {
	case PersonalDataCancellationDetailsPartyYooMoney:
		*s = PersonalDataCancellationDetailsPartyYooMoney
	default:
		*s = PersonalDataCancellationDetailsParty(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataCancellationDetailsParty) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataCancellationDetailsParty) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataCancellationDetailsReason as json.
func (s PersonalDataCancellationDetailsReason) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PersonalDataCancellationDetailsReason from json.
func (s *PersonalDataCancellationDetailsReason) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataCancellationDetailsReason to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PersonalDataCancellationDetailsReason(v) {
	case PersonalDataCancellationDetailsReasonExpiredByTimeout:
		*s = PersonalDataCancellationDetailsReasonExpiredByTimeout
	default:
		*s = PersonalDataCancellationDetailsReason(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataCancellationDetailsReason) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataCancellationDetailsReason) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataId as json.
func (s PersonalDataId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes PersonalDataId from json.
func (s *PersonalDataId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PersonalDataId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataPersonalDataIDGetInternalServerError as json.
func (s *PersonalDataPersonalDataIDGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PersonalDataPersonalDataIDGetInternalServerError from json.
func (s *PersonalDataPersonalDataIDGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataPersonalDataIDGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PersonalDataPersonalDataIDGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PersonalDataPersonalDataIDGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataPersonalDataIDGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataPersonalDataIDGetTooManyRequests as json.
func (s *PersonalDataPersonalDataIDGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PersonalDataPersonalDataIDGetTooManyRequests from json.
func (s *PersonalDataPersonalDataIDGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataPersonalDataIDGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PersonalDataPersonalDataIDGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PersonalDataPersonalDataIDGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataPersonalDataIDGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataPostInternalServerError as json.
func (s *PersonalDataPostInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PersonalDataPostInternalServerError from json.
func (s *PersonalDataPostInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataPostInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PersonalDataPostInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PersonalDataPostInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataPostInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataPostReq as json.
func (s PersonalDataPostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s PersonalDataPostReq) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SbpPayoutRecipientPersonalDataRequestPersonalDataPostReq:
		e.FieldStart("type")
		e.Str("sbp_payout_recipient")
		{
			s := s.SbpPayoutRecipientPersonalDataRequest
			{
				if s.Metadata.Set {
					e.FieldStart("metadata")
					s.Metadata.Encode(e)
				}
			}
			{
				e.FieldStart("last_name")
				s.LastName.Encode(e)
			}
			{
				e.FieldStart("first_name")
				s.FirstName.Encode(e)
			}
			{
				if s.MiddleName.Set {
					e.FieldStart("middle_name")
					s.MiddleName.Encode(e)
				}
			}
		}
	case PayoutStatementRecipientPersonalDataRequestPersonalDataPostReq:
		e.FieldStart("type")
		e.Str("payout_statement_recipient")
		{
			s := s.PayoutStatementRecipientPersonalDataRequest
			{
				if s.Metadata.Set {
					e.FieldStart("metadata")
					s.Metadata.Encode(e)
				}
			}
			{
				e.FieldStart("last_name")
				s.LastName.Encode(e)
			}
			{
				e.FieldStart("first_name")
				s.FirstName.Encode(e)
			}
			{
				if s.MiddleName.Set {
					e.FieldStart("middle_name")
					s.MiddleName.Encode(e)
				}
			}
			{
				e.FieldStart("birthdate")
				json.EncodeDate(e, s.Birthdate)
			}
		}
	}
}

// Decode decodes PersonalDataPostReq from json.
func (s *PersonalDataPostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataPostReq to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "sbp_payout_recipient":
					s.Type = SbpPayoutRecipientPersonalDataRequestPersonalDataPostReq
					found = true
				case "payout_statement_recipient":
					s.Type = PayoutStatementRecipientPersonalDataRequestPersonalDataPostReq
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SbpPayoutRecipientPersonalDataRequestPersonalDataPostReq:
		if err := s.SbpPayoutRecipientPersonalDataRequest.Decode(d); err != nil {
			return err
		}
	case PayoutStatementRecipientPersonalDataRequestPersonalDataPostReq:
		if err := s.PayoutStatementRecipientPersonalDataRequest.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataPostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataPostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataPostTooManyRequests as json.
func (s *PersonalDataPostTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes PersonalDataPostTooManyRequests from json.
func (s *PersonalDataPostTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataPostTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PersonalDataPostTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *PersonalDataPostTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataPostTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataStatus as json.
func (s PersonalDataStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PersonalDataStatus from json.
func (s *PersonalDataStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PersonalDataStatus(v) {
	case PersonalDataStatusWaitingForOperation:
		*s = PersonalDataStatusWaitingForOperation
	case PersonalDataStatusActive:
		*s = PersonalDataStatusActive
	case PersonalDataStatusCanceled:
		*s = PersonalDataStatusCanceled
	default:
		*s = PersonalDataStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PersonalDataType as json.
func (s PersonalDataType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes PersonalDataType from json.
func (s *PersonalDataType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PersonalDataType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch PersonalDataType(v) {
	case PersonalDataTypePayoutStatementRecipient:
		*s = PersonalDataTypePayoutStatementRecipient
	case PersonalDataTypeSbpPayoutRecipient:
		*s = PersonalDataTypeSbpPayoutRecipient
	default:
		*s = PersonalDataType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PersonalDataType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PersonalDataType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes PostReceiptData as json.
func (s PostReceiptData) Encode(e *jx.Encoder) {
	unwrapped := jx.Raw(s)

	if len(unwrapped) != 0 {
		e.Raw(unwrapped)
	}
}

// Decode decodes PostReceiptData from json.
func (s *PostReceiptData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode PostReceiptData to nil")
	}
	var unwrapped jx.Raw
	if err := func() error {
		v, err := d.RawAppend(nil)
		unwrapped = jx.Raw(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = PostReceiptData(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s PostReceiptData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PostReceiptData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Receipt) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Receipt) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.PaymentID.Set {
			e.FieldStart("payment_id")
			s.PaymentID.Encode(e)
		}
	}
	{
		if s.RefundID.Set {
			e.FieldStart("refund_id")
			s.RefundID.Encode(e)
		}
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.FiscalDocumentNumber.Set {
			e.FieldStart("fiscal_document_number")
			s.FiscalDocumentNumber.Encode(e)
		}
	}
	{
		if s.FiscalStorageNumber.Set {
			e.FieldStart("fiscal_storage_number")
			s.FiscalStorageNumber.Encode(e)
		}
	}
	{
		if s.FiscalAttribute.Set {
			e.FieldStart("fiscal_attribute")
			s.FiscalAttribute.Encode(e)
		}
	}
	{
		if s.RegisteredAt.Set {
			e.FieldStart("registered_at")
			s.RegisteredAt.Encode(e, json.EncodeDateTime)
		}
	}
	{
		if s.FiscalProviderID.Set {
			e.FieldStart("fiscal_provider_id")
			s.FiscalProviderID.Encode(e)
		}
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.Internet.Set {
			e.FieldStart("internet")
			s.Internet.Encode(e)
		}
	}
	{
		if s.Settlements != nil {
			e.FieldStart("settlements")
			e.ArrStart()
			for _, elem := range s.Settlements {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.OnBehalfOf.Set {
			e.FieldStart("on_behalf_of")
			s.OnBehalfOf.Encode(e)
		}
	}
	{
		if s.TaxSystemCode.Set {
			e.FieldStart("tax_system_code")
			s.TaxSystemCode.Encode(e)
		}
	}
	{
		if s.Timezone.Set {
			e.FieldStart("timezone")
			s.Timezone.Encode(e)
		}
	}
	{
		if s.ReceiptIndustryDetails != nil {
			e.FieldStart("receipt_industry_details")
			e.ArrStart()
			for _, elem := range s.ReceiptIndustryDetails {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.ReceiptOperationalDetails.Set {
			e.FieldStart("receipt_operational_details")
			s.ReceiptOperationalDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceipt = [18]string{
	0:  "id",
	1:  "type",
	2:  "payment_id",
	3:  "refund_id",
	4:  "status",
	5:  "fiscal_document_number",
	6:  "fiscal_storage_number",
	7:  "fiscal_attribute",
	8:  "registered_at",
	9:  "fiscal_provider_id",
	10: "items",
	11: "internet",
	12: "settlements",
	13: "on_behalf_of",
	14: "tax_system_code",
	15: "timezone",
	16: "receipt_industry_details",
	17: "receipt_operational_details",
}

// Decode decodes Receipt from json.
func (s *Receipt) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Receipt 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "type":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "payment_id":
			if err := func() error {
				s.PaymentID.Reset()
				if err := s.PaymentID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_id\"")
			}
		case "refund_id":
			if err := func() error {
				s.RefundID.Reset()
				if err := s.RefundID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_id\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "fiscal_document_number":
			if err := func() error {
				s.FiscalDocumentNumber.Reset()
				if err := s.FiscalDocumentNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscal_document_number\"")
			}
		case "fiscal_storage_number":
			if err := func() error {
				s.FiscalStorageNumber.Reset()
				if err := s.FiscalStorageNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscal_storage_number\"")
			}
		case "fiscal_attribute":
			if err := func() error {
				s.FiscalAttribute.Reset()
				if err := s.FiscalAttribute.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscal_attribute\"")
			}
		case "registered_at":
			if err := func() error {
				s.RegisteredAt.Reset()
				if err := s.RegisteredAt.Decode(d, json.DecodeDateTime); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"registered_at\"")
			}
		case "fiscal_provider_id":
			if err := func() error {
				s.FiscalProviderID.Reset()
				if err := s.FiscalProviderID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fiscal_provider_id\"")
			}
		case "items":
			requiredBitSet[1] |= 1 << 2
			if err := func() error {
				s.Items = make([]ReceiptItem, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ReceiptItem
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "internet":
			if err := func() error {
				s.Internet.Reset()
				if err := s.Internet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"internet\"")
			}
		case "settlements":
			if err := func() error {
				s.Settlements = make([]Settlement, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Settlement
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Settlements = append(s.Settlements, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"settlements\"")
			}
		case "on_behalf_of":
			if err := func() error {
				s.OnBehalfOf.Reset()
				if err := s.OnBehalfOf.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"on_behalf_of\"")
			}
		case "tax_system_code":
			if err := func() error {
				s.TaxSystemCode.Reset()
				if err := s.TaxSystemCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tax_system_code\"")
			}
		case "timezone":
			if err := func() error {
				s.Timezone.Reset()
				if err := s.Timezone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"timezone\"")
			}
		case "receipt_industry_details":
			if err := func() error {
				s.ReceiptIndustryDetails = make([]IndustryDetails, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem IndustryDetails
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.ReceiptIndustryDetails = append(s.ReceiptIndustryDetails, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_industry_details\"")
			}
		case "receipt_operational_details":
			if err := func() error {
				s.ReceiptOperationalDetails.Reset()
				if err := s.ReceiptOperationalDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_operational_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Receipt")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00010011,
		0b00000100,
		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(jsonFieldsNameOfReceipt) {
					name = jsonFieldsNameOfReceipt[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 *Receipt) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Receipt) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptData) encodeFields(e *jx.Encoder) {
	{
		if s.Customer.Set {
			e.FieldStart("customer")
			s.Customer.Encode(e)
		}
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.Internet.Set {
			e.FieldStart("internet")
			s.Internet.Encode(e)
		}
	}
	{
		if s.TaxSystemCode.Set {
			e.FieldStart("tax_system_code")
			s.TaxSystemCode.Encode(e)
		}
	}
	{
		if s.Timezone.Set {
			e.FieldStart("timezone")
			s.Timezone.Encode(e)
		}
	}
	{
		if s.ReceiptIndustryDetails != nil {
			e.FieldStart("receipt_industry_details")
			e.ArrStart()
			for _, elem := range s.ReceiptIndustryDetails {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.ReceiptOperationalDetails.Set {
			e.FieldStart("receipt_operational_details")
			s.ReceiptOperationalDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptData = [7]string{
	0: "customer",
	1: "items",
	2: "internet",
	3: "tax_system_code",
	4: "timezone",
	5: "receipt_industry_details",
	6: "receipt_operational_details",
}

// Decode decodes ReceiptData from json.
func (s *ReceiptData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "customer":
			if err := func() error {
				s.Customer.Reset()
				if err := s.Customer.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"customer\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]ReceiptDataItem, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem ReceiptDataItem
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "internet":
			if err := func() error {
				s.Internet.Reset()
				if err := s.Internet.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"internet\"")
			}
		case "tax_system_code":
			if err := func() error {
				s.TaxSystemCode.Reset()
				if err := s.TaxSystemCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"tax_system_code\"")
			}
		case "timezone":
			if err := func() error {
				s.Timezone.Reset()
				if err := s.Timezone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"timezone\"")
			}
		case "receipt_industry_details":
			if err := func() error {
				s.ReceiptIndustryDetails = make([]IndustryDetails, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem IndustryDetails
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.ReceiptIndustryDetails = append(s.ReceiptIndustryDetails, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_industry_details\"")
			}
		case "receipt_operational_details":
			if err := func() error {
				s.ReceiptOperationalDetails.Reset()
				if err := s.ReceiptOperationalDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_operational_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000010,
	} {
		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(jsonFieldsNameOfReceiptData) {
					name = jsonFieldsNameOfReceiptData[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 *ReceiptData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptDataCustomer) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptDataCustomer) encodeFields(e *jx.Encoder) {
	{
		if s.FullName.Set {
			e.FieldStart("full_name")
			s.FullName.Encode(e)
		}
	}
	{
		if s.Inn.Set {
			e.FieldStart("inn")
			s.Inn.Encode(e)
		}
	}
	{
		if s.Email.Set {
			e.FieldStart("email")
			s.Email.Encode(e)
		}
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptDataCustomer = [4]string{
	0: "full_name",
	1: "inn",
	2: "email",
	3: "phone",
}

// Decode decodes ReceiptDataCustomer from json.
func (s *ReceiptDataCustomer) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptDataCustomer to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "full_name":
			if err := func() error {
				s.FullName.Reset()
				if err := s.FullName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"full_name\"")
			}
		case "inn":
			if err := func() error {
				s.Inn.Reset()
				if err := s.Inn.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"inn\"")
			}
		case "email":
			if err := func() error {
				s.Email.Reset()
				if err := s.Email.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"email\"")
			}
		case "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptDataCustomer")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ReceiptDataCustomer) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptDataCustomer) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptDataItem) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptDataItem) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("description")
		s.Description.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("vat_code")
		s.VatCode.Encode(e)
	}
	{
		e.FieldStart("quantity")
		s.Quantity.Encode(e)
	}
	{
		if s.Measure.Set {
			e.FieldStart("measure")
			s.Measure.Encode(e)
		}
	}
	{
		if s.MarkQuantity.Set {
			e.FieldStart("mark_quantity")
			s.MarkQuantity.Encode(e)
		}
	}
	{
		if s.PaymentSubject.Set {
			e.FieldStart("payment_subject")
			s.PaymentSubject.Encode(e)
		}
	}
	{
		if s.PaymentMode.Set {
			e.FieldStart("payment_mode")
			s.PaymentMode.Encode(e)
		}
	}
	{
		if s.CountryOfOriginCode.Set {
			e.FieldStart("country_of_origin_code")
			s.CountryOfOriginCode.Encode(e)
		}
	}
	{
		if s.CustomsDeclarationNumber.Set {
			e.FieldStart("customs_declaration_number")
			s.CustomsDeclarationNumber.Encode(e)
		}
	}
	{
		if s.Excise.Set {
			e.FieldStart("excise")
			s.Excise.Encode(e)
		}
	}
	{
		if s.ProductCode.Set {
			e.FieldStart("product_code")
			s.ProductCode.Encode(e)
		}
	}
	{
		if s.PlannedStatus.Set {
			e.FieldStart("planned_status")
			s.PlannedStatus.Encode(e)
		}
	}
	{
		if s.MarkCodeInfo.Set {
			e.FieldStart("mark_code_info")
			s.MarkCodeInfo.Encode(e)
		}
	}
	{
		if s.MarkMode.Set {
			e.FieldStart("mark_mode")
			s.MarkMode.Encode(e)
		}
	}
	{
		if s.PaymentSubjectIndustryDetails != nil {
			e.FieldStart("payment_subject_industry_details")
			s.PaymentSubjectIndustryDetails.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptDataItem = [16]string{
	0:  "description",
	1:  "amount",
	2:  "vat_code",
	3:  "quantity",
	4:  "measure",
	5:  "mark_quantity",
	6:  "payment_subject",
	7:  "payment_mode",
	8:  "country_of_origin_code",
	9:  "customs_declaration_number",
	10: "excise",
	11: "product_code",
	12: "planned_status",
	13: "mark_code_info",
	14: "mark_mode",
	15: "payment_subject_industry_details",
}

// Decode decodes ReceiptDataItem from json.
func (s *ReceiptDataItem) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptDataItem to nil")
	}
	var requiredBitSet [2]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "description":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "vat_code":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.VatCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"vat_code\"")
			}
		case "quantity":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Quantity.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"quantity\"")
			}
		case "measure":
			if err := func() error {
				s.Measure.Reset()
				if err := s.Measure.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"measure\"")
			}
		case "mark_quantity":
			if err := func() error {
				s.MarkQuantity.Reset()
				if err := s.MarkQuantity.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_quantity\"")
			}
		case "payment_subject":
			if err := func() error {
				s.PaymentSubject.Reset()
				if err := s.PaymentSubject.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_subject\"")
			}
		case "payment_mode":
			if err := func() error {
				s.PaymentMode.Reset()
				if err := s.PaymentMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_mode\"")
			}
		case "country_of_origin_code":
			if err := func() error {
				s.CountryOfOriginCode.Reset()
				if err := s.CountryOfOriginCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"country_of_origin_code\"")
			}
		case "customs_declaration_number":
			if err := func() error {
				s.CustomsDeclarationNumber.Reset()
				if err := s.CustomsDeclarationNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"customs_declaration_number\"")
			}
		case "excise":
			if err := func() error {
				s.Excise.Reset()
				if err := s.Excise.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"excise\"")
			}
		case "product_code":
			if err := func() error {
				s.ProductCode.Reset()
				if err := s.ProductCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"product_code\"")
			}
		case "planned_status":
			if err := func() error {
				s.PlannedStatus.Reset()
				if err := s.PlannedStatus.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"planned_status\"")
			}
		case "mark_code_info":
			if err := func() error {
				s.MarkCodeInfo.Reset()
				if err := s.MarkCodeInfo.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_code_info\"")
			}
		case "mark_mode":
			if err := func() error {
				s.MarkMode.Reset()
				if err := s.MarkMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_mode\"")
			}
		case "payment_subject_industry_details":
			if err := func() error {
				if err := s.PaymentSubjectIndustryDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_subject_industry_details\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptDataItem")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b00001111,
		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(jsonFieldsNameOfReceiptDataItem) {
					name = jsonFieldsNameOfReceiptDataItem[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 *ReceiptDataItem) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptDataItem) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptDataItemAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptDataItemAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfReceiptDataItemAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes ReceiptDataItemAmount from json.
func (s *ReceiptDataItemAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptDataItemAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptDataItemAmount")
	}
	// 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(jsonFieldsNameOfReceiptDataItemAmount) {
					name = jsonFieldsNameOfReceiptDataItemAmount[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 *ReceiptDataItemAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptDataItemAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptDataReceiptOperationalDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptDataReceiptOperationalDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("operation_id")
		e.Int(s.OperationID)
	}
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
}

var jsonFieldsNameOfReceiptDataReceiptOperationalDetails = [3]string{
	0: "operation_id",
	1: "value",
	2: "created_at",
}

// Decode decodes ReceiptDataReceiptOperationalDetails from json.
func (s *ReceiptDataReceiptOperationalDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptDataReceiptOperationalDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "operation_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.OperationID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"operation_id\"")
			}
		case "value":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if 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 ReceiptDataReceiptOperationalDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfReceiptDataReceiptOperationalDetails) {
					name = jsonFieldsNameOfReceiptDataReceiptOperationalDetails[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 *ReceiptDataReceiptOperationalDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptDataReceiptOperationalDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptId as json.
func (s ReceiptId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptId from json.
func (s *ReceiptId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptItem) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptItem) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("description")
		e.Str(s.Description)
	}
	{
		e.FieldStart("quantity")
		e.Float64(s.Quantity)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("vat_code")
		e.Int32(s.VatCode)
	}
	{
		if s.PaymentSubject.Set {
			e.FieldStart("payment_subject")
			s.PaymentSubject.Encode(e)
		}
	}
	{
		if s.PaymentMode.Set {
			e.FieldStart("payment_mode")
			s.PaymentMode.Encode(e)
		}
	}
	{
		if s.CountryOfOriginCode.Set {
			e.FieldStart("country_of_origin_code")
			s.CountryOfOriginCode.Encode(e)
		}
	}
	{
		if s.CustomsDeclarationNumber.Set {
			e.FieldStart("customs_declaration_number")
			s.CustomsDeclarationNumber.Encode(e)
		}
	}
	{
		if s.Excise.Set {
			e.FieldStart("excise")
			s.Excise.Encode(e)
		}
	}
	{
		if s.Supplier.Set {
			e.FieldStart("supplier")
			s.Supplier.Encode(e)
		}
	}
	{
		if s.AgentType.Set {
			e.FieldStart("agent_type")
			s.AgentType.Encode(e)
		}
	}
	{
		if s.MarkCodeInfo.Set {
			e.FieldStart("mark_code_info")
			s.MarkCodeInfo.Encode(e)
		}
	}
	{
		if s.Measure.Set {
			e.FieldStart("measure")
			s.Measure.Encode(e)
		}
	}
	{
		if s.PaymentSubjectIndustryDetails != nil {
			e.FieldStart("payment_subject_industry_details")
			e.ArrStart()
			for _, elem := range s.PaymentSubjectIndustryDetails {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.ProductCode.Set {
			e.FieldStart("product_code")
			s.ProductCode.Encode(e)
		}
	}
	{
		if s.PlannedStatus.Set {
			e.FieldStart("planned_status")
			s.PlannedStatus.Encode(e)
		}
	}
	{
		if s.MarkMode.Set {
			e.FieldStart("mark_mode")
			s.MarkMode.Encode(e)
		}
	}
	{
		if s.MarkQuantity.Set {
			e.FieldStart("mark_quantity")
			s.MarkQuantity.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptItem = [18]string{
	0:  "description",
	1:  "quantity",
	2:  "amount",
	3:  "vat_code",
	4:  "payment_subject",
	5:  "payment_mode",
	6:  "country_of_origin_code",
	7:  "customs_declaration_number",
	8:  "excise",
	9:  "supplier",
	10: "agent_type",
	11: "mark_code_info",
	12: "measure",
	13: "payment_subject_industry_details",
	14: "product_code",
	15: "planned_status",
	16: "mark_mode",
	17: "mark_quantity",
}

// Decode decodes ReceiptItem from json.
func (s *ReceiptItem) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItem to nil")
	}
	var requiredBitSet [3]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "description":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Description = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "quantity":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Float64()
				s.Quantity = float64(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"quantity\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "vat_code":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				v, err := d.Int32()
				s.VatCode = int32(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"vat_code\"")
			}
		case "payment_subject":
			if err := func() error {
				s.PaymentSubject.Reset()
				if err := s.PaymentSubject.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_subject\"")
			}
		case "payment_mode":
			if err := func() error {
				s.PaymentMode.Reset()
				if err := s.PaymentMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_mode\"")
			}
		case "country_of_origin_code":
			if err := func() error {
				s.CountryOfOriginCode.Reset()
				if err := s.CountryOfOriginCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"country_of_origin_code\"")
			}
		case "customs_declaration_number":
			if err := func() error {
				s.CustomsDeclarationNumber.Reset()
				if err := s.CustomsDeclarationNumber.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"customs_declaration_number\"")
			}
		case "excise":
			if err := func() error {
				s.Excise.Reset()
				if err := s.Excise.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"excise\"")
			}
		case "supplier":
			if err := func() error {
				s.Supplier.Reset()
				if err := s.Supplier.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"supplier\"")
			}
		case "agent_type":
			if err := func() error {
				s.AgentType.Reset()
				if err := s.AgentType.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"agent_type\"")
			}
		case "mark_code_info":
			if err := func() error {
				s.MarkCodeInfo.Reset()
				if err := s.MarkCodeInfo.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_code_info\"")
			}
		case "measure":
			if err := func() error {
				s.Measure.Reset()
				if err := s.Measure.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"measure\"")
			}
		case "payment_subject_industry_details":
			if err := func() error {
				s.PaymentSubjectIndustryDetails = make([]IndustryDetails, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem IndustryDetails
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.PaymentSubjectIndustryDetails = append(s.PaymentSubjectIndustryDetails, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_subject_industry_details\"")
			}
		case "product_code":
			if err := func() error {
				s.ProductCode.Reset()
				if err := s.ProductCode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"product_code\"")
			}
		case "planned_status":
			if err := func() error {
				s.PlannedStatus.Reset()
				if err := s.PlannedStatus.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"planned_status\"")
			}
		case "mark_mode":
			if err := func() error {
				s.MarkMode.Reset()
				if err := s.MarkMode.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_mode\"")
			}
		case "mark_quantity":
			if err := func() error {
				s.MarkQuantity.Reset()
				if err := s.MarkQuantity.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"mark_quantity\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptItem")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [3]uint8{
		0b00001111,
		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(jsonFieldsNameOfReceiptItem) {
					name = jsonFieldsNameOfReceiptItem[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 *ReceiptItem) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItem) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemAgentType as json.
func (s ReceiptItemAgentType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptItemAgentType from json.
func (s *ReceiptItemAgentType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemAgentType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptItemAgentType(v) {
	case ReceiptItemAgentTypeBankingPaymentAgent:
		*s = ReceiptItemAgentTypeBankingPaymentAgent
	case ReceiptItemAgentTypeBankingPaymentSubagent:
		*s = ReceiptItemAgentTypeBankingPaymentSubagent
	case ReceiptItemAgentTypePaymentAgent:
		*s = ReceiptItemAgentTypePaymentAgent
	case ReceiptItemAgentTypePaymentSubagent:
		*s = ReceiptItemAgentTypePaymentSubagent
	case ReceiptItemAgentTypeAttorney:
		*s = ReceiptItemAgentTypeAttorney
	case ReceiptItemAgentTypeCommissioner:
		*s = ReceiptItemAgentTypeCommissioner
	case ReceiptItemAgentTypeAgent:
		*s = ReceiptItemAgentTypeAgent
	default:
		*s = ReceiptItemAgentType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemAgentType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemAgentType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptItemAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptItemAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfReceiptItemAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes ReceiptItemAmount from json.
func (s *ReceiptItemAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptItemAmount")
	}
	// 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(jsonFieldsNameOfReceiptItemAmount) {
					name = jsonFieldsNameOfReceiptItemAmount[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 *ReceiptItemAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemCountryOfOriginCode as json.
func (s ReceiptItemCountryOfOriginCode) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptItemCountryOfOriginCode from json.
func (s *ReceiptItemCountryOfOriginCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemCountryOfOriginCode to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemCountryOfOriginCode(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemCountryOfOriginCode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemCountryOfOriginCode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemCustomsDeclarationNumber as json.
func (s ReceiptItemCustomsDeclarationNumber) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptItemCustomsDeclarationNumber from json.
func (s *ReceiptItemCustomsDeclarationNumber) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemCustomsDeclarationNumber to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemCustomsDeclarationNumber(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemCustomsDeclarationNumber) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemCustomsDeclarationNumber) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemDescription as json.
func (s ReceiptItemDescription) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptItemDescription from json.
func (s *ReceiptItemDescription) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemDescription to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemDescription(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemDescription) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemDescription) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemExcise as json.
func (s ReceiptItemExcise) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptItemExcise from json.
func (s *ReceiptItemExcise) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemExcise to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemExcise(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemExcise) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemExcise) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemMeasure as json.
func (s ReceiptItemMeasure) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptItemMeasure from json.
func (s *ReceiptItemMeasure) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemMeasure to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptItemMeasure(v) {
	case ReceiptItemMeasurePiece:
		*s = ReceiptItemMeasurePiece
	case ReceiptItemMeasureGram:
		*s = ReceiptItemMeasureGram
	case ReceiptItemMeasureKilogram:
		*s = ReceiptItemMeasureKilogram
	case ReceiptItemMeasureTon:
		*s = ReceiptItemMeasureTon
	case ReceiptItemMeasureCentimeter:
		*s = ReceiptItemMeasureCentimeter
	case ReceiptItemMeasureDecimeter:
		*s = ReceiptItemMeasureDecimeter
	case ReceiptItemMeasureMeter:
		*s = ReceiptItemMeasureMeter
	case ReceiptItemMeasureSquareCentimeter:
		*s = ReceiptItemMeasureSquareCentimeter
	case ReceiptItemMeasureSquareDecimeter:
		*s = ReceiptItemMeasureSquareDecimeter
	case ReceiptItemMeasureSquareMeter:
		*s = ReceiptItemMeasureSquareMeter
	case ReceiptItemMeasureMilliliter:
		*s = ReceiptItemMeasureMilliliter
	case ReceiptItemMeasureLiter:
		*s = ReceiptItemMeasureLiter
	case ReceiptItemMeasureCubicMeter:
		*s = ReceiptItemMeasureCubicMeter
	case ReceiptItemMeasureKilowattHour:
		*s = ReceiptItemMeasureKilowattHour
	case ReceiptItemMeasureGigacalorie:
		*s = ReceiptItemMeasureGigacalorie
	case ReceiptItemMeasureDay:
		*s = ReceiptItemMeasureDay
	case ReceiptItemMeasureHour:
		*s = ReceiptItemMeasureHour
	case ReceiptItemMeasureMinute:
		*s = ReceiptItemMeasureMinute
	case ReceiptItemMeasureSecond:
		*s = ReceiptItemMeasureSecond
	case ReceiptItemMeasureKilobyte:
		*s = ReceiptItemMeasureKilobyte
	case ReceiptItemMeasureMegabyte:
		*s = ReceiptItemMeasureMegabyte
	case ReceiptItemMeasureGigabyte:
		*s = ReceiptItemMeasureGigabyte
	case ReceiptItemMeasureTerabyte:
		*s = ReceiptItemMeasureTerabyte
	case ReceiptItemMeasureAnother:
		*s = ReceiptItemMeasureAnother
	default:
		*s = ReceiptItemMeasure(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemMeasure) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemMeasure) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemPaymentMode as json.
func (s ReceiptItemPaymentMode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptItemPaymentMode from json.
func (s *ReceiptItemPaymentMode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemPaymentMode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptItemPaymentMode(v) {
	case ReceiptItemPaymentModeFullPrepayment:
		*s = ReceiptItemPaymentModeFullPrepayment
	case ReceiptItemPaymentModePartialPrepayment:
		*s = ReceiptItemPaymentModePartialPrepayment
	case ReceiptItemPaymentModeAdvance:
		*s = ReceiptItemPaymentModeAdvance
	case ReceiptItemPaymentModeFullPayment:
		*s = ReceiptItemPaymentModeFullPayment
	case ReceiptItemPaymentModePartialPayment:
		*s = ReceiptItemPaymentModePartialPayment
	case ReceiptItemPaymentModeCredit:
		*s = ReceiptItemPaymentModeCredit
	case ReceiptItemPaymentModeCreditPayment:
		*s = ReceiptItemPaymentModeCreditPayment
	default:
		*s = ReceiptItemPaymentMode(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemPaymentMode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemPaymentMode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemPaymentSubject as json.
func (s ReceiptItemPaymentSubject) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptItemPaymentSubject from json.
func (s *ReceiptItemPaymentSubject) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemPaymentSubject to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptItemPaymentSubject(v) {
	case ReceiptItemPaymentSubjectCommodity:
		*s = ReceiptItemPaymentSubjectCommodity
	case ReceiptItemPaymentSubjectExcise:
		*s = ReceiptItemPaymentSubjectExcise
	case ReceiptItemPaymentSubjectJob:
		*s = ReceiptItemPaymentSubjectJob
	case ReceiptItemPaymentSubjectService:
		*s = ReceiptItemPaymentSubjectService
	case ReceiptItemPaymentSubjectGamblingBet:
		*s = ReceiptItemPaymentSubjectGamblingBet
	case ReceiptItemPaymentSubjectGamblingPrize:
		*s = ReceiptItemPaymentSubjectGamblingPrize
	case ReceiptItemPaymentSubjectLottery:
		*s = ReceiptItemPaymentSubjectLottery
	case ReceiptItemPaymentSubjectLotteryPrize:
		*s = ReceiptItemPaymentSubjectLotteryPrize
	case ReceiptItemPaymentSubjectIntellectualActivity:
		*s = ReceiptItemPaymentSubjectIntellectualActivity
	case ReceiptItemPaymentSubjectPayment:
		*s = ReceiptItemPaymentSubjectPayment
	case ReceiptItemPaymentSubjectAgentCommission:
		*s = ReceiptItemPaymentSubjectAgentCommission
	case ReceiptItemPaymentSubjectPropertyRight:
		*s = ReceiptItemPaymentSubjectPropertyRight
	case ReceiptItemPaymentSubjectNonOperatingGain:
		*s = ReceiptItemPaymentSubjectNonOperatingGain
	case ReceiptItemPaymentSubjectInsurancePremium:
		*s = ReceiptItemPaymentSubjectInsurancePremium
	case ReceiptItemPaymentSubjectSalesTax:
		*s = ReceiptItemPaymentSubjectSalesTax
	case ReceiptItemPaymentSubjectResortFee:
		*s = ReceiptItemPaymentSubjectResortFee
	case ReceiptItemPaymentSubjectComposite:
		*s = ReceiptItemPaymentSubjectComposite
	case ReceiptItemPaymentSubjectAnother:
		*s = ReceiptItemPaymentSubjectAnother
	case ReceiptItemPaymentSubjectFine:
		*s = ReceiptItemPaymentSubjectFine
	case ReceiptItemPaymentSubjectTax:
		*s = ReceiptItemPaymentSubjectTax
	case ReceiptItemPaymentSubjectLien:
		*s = ReceiptItemPaymentSubjectLien
	case ReceiptItemPaymentSubjectCost:
		*s = ReceiptItemPaymentSubjectCost
	case ReceiptItemPaymentSubjectPensionInsuranceWithoutPayouts:
		*s = ReceiptItemPaymentSubjectPensionInsuranceWithoutPayouts
	case ReceiptItemPaymentSubjectPensionInsuranceWithPayouts:
		*s = ReceiptItemPaymentSubjectPensionInsuranceWithPayouts
	case ReceiptItemPaymentSubjectHealthInsuranceWithoutPayouts:
		*s = ReceiptItemPaymentSubjectHealthInsuranceWithoutPayouts
	case ReceiptItemPaymentSubjectHealthInsuranceWithPayouts:
		*s = ReceiptItemPaymentSubjectHealthInsuranceWithPayouts
	case ReceiptItemPaymentSubjectHealthInsurance:
		*s = ReceiptItemPaymentSubjectHealthInsurance
	case ReceiptItemPaymentSubjectCasino:
		*s = ReceiptItemPaymentSubjectCasino
	case ReceiptItemPaymentSubjectAgentWithdrawals:
		*s = ReceiptItemPaymentSubjectAgentWithdrawals
	case ReceiptItemPaymentSubjectNonMarkedExcise:
		*s = ReceiptItemPaymentSubjectNonMarkedExcise
	case ReceiptItemPaymentSubjectMarkedExcise:
		*s = ReceiptItemPaymentSubjectMarkedExcise
	case ReceiptItemPaymentSubjectMarked:
		*s = ReceiptItemPaymentSubjectMarked
	case ReceiptItemPaymentSubjectNonMarked:
		*s = ReceiptItemPaymentSubjectNonMarked
	default:
		*s = ReceiptItemPaymentSubject(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemPaymentSubject) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemPaymentSubject) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemPaymentSubjectIndustryDetails as json.
func (s ReceiptItemPaymentSubjectIndustryDetails) Encode(e *jx.Encoder) {
	unwrapped := []IndustryDetails(s)
	if unwrapped == nil {
		e.ArrEmpty()
		return
	}
	if unwrapped != nil {
		e.ArrStart()
		for _, elem := range unwrapped {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
}

// Decode decodes ReceiptItemPaymentSubjectIndustryDetails from json.
func (s *ReceiptItemPaymentSubjectIndustryDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemPaymentSubjectIndustryDetails to nil")
	}
	var unwrapped []IndustryDetails
	if err := func() error {
		unwrapped = make([]IndustryDetails, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem IndustryDetails
			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 = ReceiptItemPaymentSubjectIndustryDetails(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemPaymentSubjectIndustryDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemPaymentSubjectIndustryDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemPlannedStatus as json.
func (s ReceiptItemPlannedStatus) Encode(e *jx.Encoder) {
	unwrapped := int32(s)

	e.Int32(unwrapped)
}

// Decode decodes ReceiptItemPlannedStatus from json.
func (s *ReceiptItemPlannedStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemPlannedStatus to nil")
	}
	var unwrapped int32
	if err := func() error {
		v, err := d.Int32()
		unwrapped = int32(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemPlannedStatus(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemPlannedStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemPlannedStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemProductCode as json.
func (s ReceiptItemProductCode) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReceiptItemProductCode from json.
func (s *ReceiptItemProductCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemProductCode to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemProductCode(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemProductCode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemProductCode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemQuantity as json.
func (s ReceiptItemQuantity) Encode(e *jx.Encoder) {
	unwrapped := float64(s)

	e.Float64(unwrapped)
}

// Decode decodes ReceiptItemQuantity from json.
func (s *ReceiptItemQuantity) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemQuantity to nil")
	}
	var unwrapped float64
	if err := func() error {
		v, err := d.Float64()
		unwrapped = float64(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemQuantity(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemQuantity) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemQuantity) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptItemSupplierWithInn) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptItemSupplierWithInn) encodeFields(e *jx.Encoder) {
	{
		if s.Name.Set {
			e.FieldStart("name")
			s.Name.Encode(e)
		}
	}
	{
		if s.Phone.Set {
			e.FieldStart("phone")
			s.Phone.Encode(e)
		}
	}
	{
		if s.Inn.Set {
			e.FieldStart("inn")
			s.Inn.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptItemSupplierWithInn = [3]string{
	0: "name",
	1: "phone",
	2: "inn",
}

// Decode decodes ReceiptItemSupplierWithInn from json.
func (s *ReceiptItemSupplierWithInn) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemSupplierWithInn 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 "phone":
			if err := func() error {
				s.Phone.Reset()
				if err := s.Phone.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		case "inn":
			if err := func() error {
				s.Inn.Reset()
				if err := s.Inn.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"inn\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptItemSupplierWithInn")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *ReceiptItemSupplierWithInn) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemSupplierWithInn) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptItemVatCode as json.
func (s ReceiptItemVatCode) Encode(e *jx.Encoder) {
	unwrapped := int32(s)

	e.Int32(unwrapped)
}

// Decode decodes ReceiptItemVatCode from json.
func (s *ReceiptItemVatCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptItemVatCode to nil")
	}
	var unwrapped int32
	if err := func() error {
		v, err := d.Int32()
		unwrapped = int32(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReceiptItemVatCode(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptItemVatCode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptItemVatCode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptReceiptOperationalDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptReceiptOperationalDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("operation_id")
		e.Int(s.OperationID)
	}
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
}

var jsonFieldsNameOfReceiptReceiptOperationalDetails = [3]string{
	0: "operation_id",
	1: "value",
	2: "created_at",
}

// Decode decodes ReceiptReceiptOperationalDetails from json.
func (s *ReceiptReceiptOperationalDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptReceiptOperationalDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "operation_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Int()
				s.OperationID = int(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"operation_id\"")
			}
		case "value":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if 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 ReceiptReceiptOperationalDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfReceiptReceiptOperationalDetails) {
					name = jsonFieldsNameOfReceiptReceiptOperationalDetails[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 *ReceiptReceiptOperationalDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptReceiptOperationalDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptStatus as json.
func (s ReceiptStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptStatus from json.
func (s *ReceiptStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptStatus(v) {
	case ReceiptStatusPending:
		*s = ReceiptStatusPending
	case ReceiptStatusSucceeded:
		*s = ReceiptStatusSucceeded
	case ReceiptStatusCanceled:
		*s = ReceiptStatusCanceled
	default:
		*s = ReceiptStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptType as json.
func (s ReceiptType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptType from json.
func (s *ReceiptType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptType(v) {
	case ReceiptTypePayment:
		*s = ReceiptTypePayment
	case ReceiptTypeRefund:
		*s = ReceiptTypeRefund
	default:
		*s = ReceiptType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiptsGetOK) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiptsGetOK) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.NextCursor.Set {
			e.FieldStart("next_cursor")
			s.NextCursor.Encode(e)
		}
	}
}

var jsonFieldsNameOfReceiptsGetOK = [3]string{
	0: "type",
	1: "items",
	2: "next_cursor",
}

// Decode decodes ReceiptsGetOK from json.
func (s *ReceiptsGetOK) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptsGetOK to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]Receipt, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Receipt
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "next_cursor":
			if err := func() error {
				s.NextCursor.Reset()
				if err := s.NextCursor.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next_cursor\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiptsGetOK")
	}
	// 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(jsonFieldsNameOfReceiptsGetOK) {
					name = jsonFieldsNameOfReceiptsGetOK[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 *ReceiptsGetOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptsGetOK) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiptsGetOKType as json.
func (s ReceiptsGetOKType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiptsGetOKType from json.
func (s *ReceiptsGetOKType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiptsGetOKType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiptsGetOKType(v) {
	case ReceiptsGetOKTypeList:
		*s = ReceiptsGetOKTypeList
	default:
		*s = ReceiptsGetOKType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiptsGetOKType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiptsGetOKType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiverBankAccount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiverBankAccount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("account_number")
		e.Str(s.AccountNumber)
	}
	{
		e.FieldStart("bic")
		e.Str(s.Bic)
	}
}

var jsonFieldsNameOfReceiverBankAccount = [3]string{
	0: "type",
	1: "account_number",
	2: "bic",
}

// Decode decodes ReceiverBankAccount from json.
func (s *ReceiverBankAccount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiverBankAccount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "account_number":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.AccountNumber = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		case "bic":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.Bic = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bic\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiverBankAccount")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfReceiverBankAccount) {
					name = jsonFieldsNameOfReceiverBankAccount[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 *ReceiverBankAccount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiverBankAccount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiverDigitalWallet) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiverDigitalWallet) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("account_number")
		e.Str(s.AccountNumber)
	}
}

var jsonFieldsNameOfReceiverDigitalWallet = [2]string{
	0: "type",
	1: "account_number",
}

// Decode decodes ReceiverDigitalWallet from json.
func (s *ReceiverDigitalWallet) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiverDigitalWallet to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "account_number":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.AccountNumber = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiverDigitalWallet")
	}
	// 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(jsonFieldsNameOfReceiverDigitalWallet) {
					name = jsonFieldsNameOfReceiverDigitalWallet[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 *ReceiverDigitalWallet) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiverDigitalWallet) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ReceiverMobileBalance) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ReceiverMobileBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("phone")
		e.Str(s.Phone)
	}
}

var jsonFieldsNameOfReceiverMobileBalance = [2]string{
	0: "type",
	1: "phone",
}

// Decode decodes ReceiverMobileBalance from json.
func (s *ReceiverMobileBalance) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiverMobileBalance to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Phone = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ReceiverMobileBalance")
	}
	// 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(jsonFieldsNameOfReceiverMobileBalance) {
					name = jsonFieldsNameOfReceiverMobileBalance[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 *ReceiverMobileBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiverMobileBalance) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReceiverType as json.
func (s ReceiverType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes ReceiverType from json.
func (s *ReceiverType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReceiverType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch ReceiverType(v) {
	case ReceiverTypeMobileBalance:
		*s = ReceiverTypeMobileBalance
	case ReceiverTypeDigitalWallet:
		*s = ReceiverTypeDigitalWallet
	case ReceiverTypeBankAccount:
		*s = ReceiverTypeBankAccount
	default:
		*s = ReceiverType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReceiverType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReceiverType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Recipient) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Recipient) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("gateway_id")
		s.GatewayID.Encode(e)
	}
}

var jsonFieldsNameOfRecipient = [1]string{
	0: "gateway_id",
}

// Decode decodes Recipient from json.
func (s *Recipient) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Recipient to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "gateway_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.GatewayID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gateway_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Recipient")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfRecipient) {
					name = jsonFieldsNameOfRecipient[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 *Recipient) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Recipient) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Refund) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Refund) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("payment_id")
		s.PaymentID.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.CancellationDetails.Set {
			e.FieldStart("cancellation_details")
			s.CancellationDetails.Encode(e)
		}
	}
	{
		if s.ReceiptRegistration.Set {
			e.FieldStart("receipt_registration")
			s.ReceiptRegistration.Encode(e)
		}
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Sources != nil {
			e.FieldStart("sources")
			e.ArrStart()
			for _, elem := range s.Sources {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.RefundMethod.Set {
			e.FieldStart("refund_method")
			s.RefundMethod.Encode(e)
		}
	}
	{
		if s.RefundAuthorizationDetails.Set {
			e.FieldStart("refund_authorization_details")
			s.RefundAuthorizationDetails.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfRefund = [13]string{
	0:  "id",
	1:  "payment_id",
	2:  "status",
	3:  "cancellation_details",
	4:  "receipt_registration",
	5:  "created_at",
	6:  "amount",
	7:  "description",
	8:  "sources",
	9:  "deal",
	10: "refund_method",
	11: "refund_authorization_details",
	12: "metadata",
}

// Decode decodes Refund from json.
func (s *Refund) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Refund 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 {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "payment_id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.PaymentID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_id\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "cancellation_details":
			if err := func() error {
				s.CancellationDetails.Reset()
				if err := s.CancellationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"cancellation_details\"")
			}
		case "receipt_registration":
			if err := func() error {
				s.ReceiptRegistration.Reset()
				if err := s.ReceiptRegistration.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt_registration\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 6
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "sources":
			if err := func() error {
				s.Sources = make([]RefundSourcesData, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem RefundSourcesData
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Sources = append(s.Sources, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sources\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "refund_method":
			if err := func() error {
				s.RefundMethod.Reset()
				if err := s.RefundMethod.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_method\"")
			}
		case "refund_authorization_details":
			if err := func() error {
				s.RefundAuthorizationDetails.Reset()
				if err := s.RefundAuthorizationDetails.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_authorization_details\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Refund")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b01100111,
		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(jsonFieldsNameOfRefund) {
					name = jsonFieldsNameOfRefund[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 *Refund) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Refund) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfRefundAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes RefundAmount from json.
func (s *RefundAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundAmount")
	}
	// 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(jsonFieldsNameOfRefundAmount) {
					name = jsonFieldsNameOfRefundAmount[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 *RefundAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundAuthorizationDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundAuthorizationDetails) encodeFields(e *jx.Encoder) {
	{
		if s.Rrn.Set {
			e.FieldStart("rrn")
			s.Rrn.Encode(e)
		}
	}
}

var jsonFieldsNameOfRefundAuthorizationDetails = [1]string{
	0: "rrn",
}

// Decode decodes RefundAuthorizationDetails from json.
func (s *RefundAuthorizationDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundAuthorizationDetails to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "rrn":
			if err := func() error {
				s.Rrn.Reset()
				if err := s.Rrn.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"rrn\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundAuthorizationDetails")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *RefundAuthorizationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundAuthorizationDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundCancellationDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundCancellationDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("party")
		s.Party.Encode(e)
	}
	{
		e.FieldStart("reason")
		s.Reason.Encode(e)
	}
}

var jsonFieldsNameOfRefundCancellationDetails = [2]string{
	0: "party",
	1: "reason",
}

// Decode decodes RefundCancellationDetails from json.
func (s *RefundCancellationDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundCancellationDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "party":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Party.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"party\"")
			}
		case "reason":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Reason.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"reason\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundCancellationDetails")
	}
	// 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(jsonFieldsNameOfRefundCancellationDetails) {
					name = jsonFieldsNameOfRefundCancellationDetails[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 *RefundCancellationDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundCancellationDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundCancellationDetailsParty as json.
func (s RefundCancellationDetailsParty) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundCancellationDetailsParty from json.
func (s *RefundCancellationDetailsParty) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundCancellationDetailsParty to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundCancellationDetailsParty(v) {
	case RefundCancellationDetailsPartyYooMoney:
		*s = RefundCancellationDetailsPartyYooMoney
	case RefundCancellationDetailsPartyRefundNetwork:
		*s = RefundCancellationDetailsPartyRefundNetwork
	default:
		*s = RefundCancellationDetailsParty(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundCancellationDetailsParty) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundCancellationDetailsParty) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundCancellationDetailsReason as json.
func (s RefundCancellationDetailsReason) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundCancellationDetailsReason from json.
func (s *RefundCancellationDetailsReason) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundCancellationDetailsReason to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundCancellationDetailsReason(v) {
	case RefundCancellationDetailsReasonYooMoneyAccountClosed:
		*s = RefundCancellationDetailsReasonYooMoneyAccountClosed
	case RefundCancellationDetailsReasonInsufficientFunds:
		*s = RefundCancellationDetailsReasonInsufficientFunds
	case RefundCancellationDetailsReasonGeneralDecline:
		*s = RefundCancellationDetailsReasonGeneralDecline
	case RefundCancellationDetailsReasonRejectedByPayee:
		*s = RefundCancellationDetailsReasonRejectedByPayee
	case RefundCancellationDetailsReasonRejectedByTimeout:
		*s = RefundCancellationDetailsReasonRejectedByTimeout
	case RefundCancellationDetailsReasonPaymentBasketIDNotFound:
		*s = RefundCancellationDetailsReasonPaymentBasketIDNotFound
	case RefundCancellationDetailsReasonPaymentArticleNumberNotFound:
		*s = RefundCancellationDetailsReasonPaymentArticleNumberNotFound
	case RefundCancellationDetailsReasonPaymentTruCodeNotFound:
		*s = RefundCancellationDetailsReasonPaymentTruCodeNotFound
	case RefundCancellationDetailsReasonTooManyRefundingArticles:
		*s = RefundCancellationDetailsReasonTooManyRefundingArticles
	case RefundCancellationDetailsReasonSomeArticlesAlreadyRefunded:
		*s = RefundCancellationDetailsReasonSomeArticlesAlreadyRefunded
	default:
		*s = RefundCancellationDetailsReason(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundCancellationDetailsReason) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundCancellationDetailsReason) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundDealData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundDealData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("refund_settlements")
		s.RefundSettlements.Encode(e)
	}
}

var jsonFieldsNameOfRefundDealData = [1]string{
	0: "refund_settlements",
}

// Decode decodes RefundDealData from json.
func (s *RefundDealData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundDealData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "refund_settlements":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.RefundSettlements.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_settlements\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundDealData")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfRefundDealData) {
					name = jsonFieldsNameOfRefundDealData[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 *RefundDealData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundDealData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundDealInfo) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundDealInfo) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("refund_settlements")
		s.RefundSettlements.Encode(e)
	}
}

var jsonFieldsNameOfRefundDealInfo = [2]string{
	0: "id",
	1: "refund_settlements",
}

// Decode decodes RefundDealInfo from json.
func (s *RefundDealInfo) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundDealInfo 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.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "refund_settlements":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.RefundSettlements.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_settlements\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundDealInfo")
	}
	// 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(jsonFieldsNameOfRefundDealInfo) {
					name = jsonFieldsNameOfRefundDealInfo[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 *RefundDealInfo) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundDealInfo) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundId as json.
func (s RefundId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes RefundId from json.
func (s *RefundId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = RefundId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundList) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
	{
		if s.NextCursor.Set {
			e.FieldStart("next_cursor")
			s.NextCursor.Encode(e)
		}
	}
}

var jsonFieldsNameOfRefundList = [3]string{
	0: "type",
	1: "items",
	2: "next_cursor",
}

// Decode decodes RefundList from json.
func (s *RefundList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundList to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]Refund, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Refund
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		case "next_cursor":
			if err := func() error {
				s.NextCursor.Reset()
				if err := s.NextCursor.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"next_cursor\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundList")
	}
	// 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(jsonFieldsNameOfRefundList) {
					name = jsonFieldsNameOfRefundList[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 *RefundList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundListType as json.
func (s RefundListType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundListType from json.
func (s *RefundListType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundListType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundListType(v) {
	case RefundListTypeList:
		*s = RefundListTypeList
	default:
		*s = RefundListType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundListType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundListType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundMethodType as json.
func (s RefundMethodType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundMethodType from json.
func (s *RefundMethodType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundMethodType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundMethodType(v) {
	case RefundMethodTypeSbp:
		*s = RefundMethodTypeSbp
	case RefundMethodTypeElectronicCertificate:
		*s = RefundMethodTypeElectronicCertificate
	default:
		*s = RefundMethodType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundMethodType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundMethodType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundReceiptRegistration as json.
func (s RefundReceiptRegistration) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundReceiptRegistration from json.
func (s *RefundReceiptRegistration) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundReceiptRegistration to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundReceiptRegistration(v) {
	case RefundReceiptRegistrationPending:
		*s = RefundReceiptRegistrationPending
	case RefundReceiptRegistrationSucceeded:
		*s = RefundReceiptRegistrationSucceeded
	case RefundReceiptRegistrationCanceled:
		*s = RefundReceiptRegistrationCanceled
	default:
		*s = RefundReceiptRegistration(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundReceiptRegistration) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundReceiptRegistration) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundRefundMethod as json.
func (s RefundRefundMethod) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s RefundRefundMethod) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SbpRefundMethodRefundRefundMethod:
		e.FieldStart("type")
		e.Str("SbpRefundMethod")
		{
			s := s.SbpRefundMethod
			{
				if s.SbpOperationID.Set {
					e.FieldStart("sbp_operation_id")
					s.SbpOperationID.Encode(e)
				}
			}
		}
	case ElectronicCertificateRefundMethodRefundRefundMethod:
		e.FieldStart("type")
		e.Str("ElectronicCertificateRefundMethod")
		{
			s := s.ElectronicCertificateRefundMethod
			{
				if s.ElectronicCertificate.Set {
					e.FieldStart("electronic_certificate")
					s.ElectronicCertificate.Encode(e)
				}
			}
			{
				if s.Articles != nil {
					e.FieldStart("articles")
					e.ArrStart()
					for _, elem := range s.Articles {
						elem.Encode(e)
					}
					e.ArrEnd()
				}
			}
		}
	}
}

// Decode decodes RefundRefundMethod from json.
func (s *RefundRefundMethod) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundRefundMethod to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SbpRefundMethod":
					s.Type = SbpRefundMethodRefundRefundMethod
					found = true
				case "ElectronicCertificateRefundMethod":
					s.Type = ElectronicCertificateRefundMethodRefundRefundMethod
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SbpRefundMethodRefundRefundMethod:
		if err := s.SbpRefundMethod.Decode(d); err != nil {
			return err
		}
	case ElectronicCertificateRefundMethodRefundRefundMethod:
		if err := s.ElectronicCertificateRefundMethod.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundRefundMethod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundRefundMethod) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundSourcesData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundSourcesData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		e.Str(s.AccountID)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.PlatformFeeAmount.Set {
			e.FieldStart("platform_fee_amount")
			s.PlatformFeeAmount.Encode(e)
		}
	}
}

var jsonFieldsNameOfRefundSourcesData = [3]string{
	0: "account_id",
	1: "amount",
	2: "platform_fee_amount",
}

// Decode decodes RefundSourcesData from json.
func (s *RefundSourcesData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundSourcesData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.AccountID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "platform_fee_amount":
			if err := func() error {
				s.PlatformFeeAmount.Reset()
				if err := s.PlatformFeeAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"platform_fee_amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundSourcesData")
	}
	// 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(jsonFieldsNameOfRefundSourcesData) {
					name = jsonFieldsNameOfRefundSourcesData[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 *RefundSourcesData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundSourcesData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundSourcesDataAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundSourcesDataAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfRefundSourcesDataAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes RefundSourcesDataAmount from json.
func (s *RefundSourcesDataAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundSourcesDataAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundSourcesDataAmount")
	}
	// 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(jsonFieldsNameOfRefundSourcesDataAmount) {
					name = jsonFieldsNameOfRefundSourcesDataAmount[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 *RefundSourcesDataAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundSourcesDataAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundSourcesDataPlatformFeeAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundSourcesDataPlatformFeeAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfRefundSourcesDataPlatformFeeAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes RefundSourcesDataPlatformFeeAmount from json.
func (s *RefundSourcesDataPlatformFeeAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundSourcesDataPlatformFeeAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundSourcesDataPlatformFeeAmount")
	}
	// 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(jsonFieldsNameOfRefundSourcesDataPlatformFeeAmount) {
					name = jsonFieldsNameOfRefundSourcesDataPlatformFeeAmount[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 *RefundSourcesDataPlatformFeeAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundSourcesDataPlatformFeeAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundStatus as json.
func (s RefundStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes RefundStatus from json.
func (s *RefundStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch RefundStatus(v) {
	case RefundStatusPending:
		*s = RefundStatusPending
	case RefundStatusSucceeded:
		*s = RefundStatusSucceeded
	case RefundStatusCanceled:
		*s = RefundStatusCanceled
	default:
		*s = RefundStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundsPostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundsPostReq) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("payment_id")
		s.PaymentID.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Receipt.Set {
			e.FieldStart("receipt")
			s.Receipt.Encode(e)
		}
	}
	{
		if s.Sources != nil {
			e.FieldStart("sources")
			e.ArrStart()
			for _, elem := range s.Sources {
				elem.Encode(e)
			}
			e.ArrEnd()
		}
	}
	{
		if s.Deal.Set {
			e.FieldStart("deal")
			s.Deal.Encode(e)
		}
	}
	{
		if s.RefundMethodData.Set {
			e.FieldStart("refund_method_data")
			s.RefundMethodData.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfRefundsPostReq = [8]string{
	0: "payment_id",
	1: "amount",
	2: "description",
	3: "receipt",
	4: "sources",
	5: "deal",
	6: "refund_method_data",
	7: "metadata",
}

// Decode decodes RefundsPostReq from json.
func (s *RefundsPostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundsPostReq to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "payment_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.PaymentID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payment_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "receipt":
			if err := func() error {
				s.Receipt.Reset()
				if err := s.Receipt.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"receipt\"")
			}
		case "sources":
			if err := func() error {
				s.Sources = make([]RefundSourcesData, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem RefundSourcesData
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Sources = append(s.Sources, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sources\"")
			}
		case "deal":
			if err := func() error {
				s.Deal.Reset()
				if err := s.Deal.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"deal\"")
			}
		case "refund_method_data":
			if err := func() error {
				s.RefundMethodData.Reset()
				if err := s.RefundMethodData.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"refund_method_data\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundsPostReq")
	}
	// 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(jsonFieldsNameOfRefundsPostReq) {
					name = jsonFieldsNameOfRefundsPostReq[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 *RefundsPostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundsPostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *RefundsPostReqAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *RefundsPostReqAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfRefundsPostReqAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes RefundsPostReqAmount from json.
func (s *RefundsPostReqAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundsPostReqAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode RefundsPostReqAmount")
	}
	// 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(jsonFieldsNameOfRefundsPostReqAmount) {
					name = jsonFieldsNameOfRefundsPostReqAmount[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 *RefundsPostReqAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundsPostReqAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes RefundsPostReqRefundMethodData as json.
func (s RefundsPostReqRefundMethodData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s RefundsPostReqRefundMethodData) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case ElectronicCertificateRefundMethodDataRefundsPostReqRefundMethodData:
		e.FieldStart("type")
		e.Str("ElectronicCertificateRefundMethodData")
		{
			s := s.ElectronicCertificateRefundMethodData
			{
				if s.ElectronicCertificate.Set {
					e.FieldStart("electronic_certificate")
					s.ElectronicCertificate.Encode(e)
				}
			}
			{
				if s.Articles != nil {
					e.FieldStart("articles")
					e.ArrStart()
					for _, elem := range s.Articles {
						elem.Encode(e)
					}
					e.ArrEnd()
				}
			}
		}
	}
}

// Decode decodes RefundsPostReqRefundMethodData from json.
func (s *RefundsPostReqRefundMethodData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode RefundsPostReqRefundMethodData to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "ElectronicCertificateRefundMethodData":
					s.Type = ElectronicCertificateRefundMethodDataRefundsPostReqRefundMethodData
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case ElectronicCertificateRefundMethodDataRefundsPostReqRefundMethodData:
		if err := s.ElectronicCertificateRefundMethodData.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s RefundsPostReqRefundMethodData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RefundsPostReqRefundMethodData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes ReturnUrl as json.
func (s ReturnUrl) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes ReturnUrl from json.
func (s *ReturnUrl) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ReturnUrl to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = ReturnUrl(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s ReturnUrl) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ReturnUrl) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes Rrn as json.
func (s Rrn) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes Rrn from json.
func (s *Rrn) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Rrn to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Rrn(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s Rrn) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Rrn) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SafeDeal) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SafeDeal) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		s.ID.Encode(e)
	}
	{
		e.FieldStart("fee_moment")
		s.FeeMoment.Encode(e)
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		e.FieldStart("balance")
		s.Balance.Encode(e)
	}
	{
		e.FieldStart("payout_balance")
		s.PayoutBalance.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		e.FieldStart("created_at")
		json.EncodeDateTime(e, s.CreatedAt)
	}
	{
		e.FieldStart("expires_at")
		json.EncodeDateTime(e, s.ExpiresAt)
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		e.FieldStart("test")
		s.Test.Encode(e)
	}
}

var jsonFieldsNameOfSafeDeal = [11]string{
	0:  "type",
	1:  "id",
	2:  "fee_moment",
	3:  "description",
	4:  "balance",
	5:  "payout_balance",
	6:  "status",
	7:  "created_at",
	8:  "expires_at",
	9:  "metadata",
	10: "test",
}

// Decode decodes SafeDeal from json.
func (s *SafeDeal) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SafeDeal to nil")
	}
	var requiredBitSet [2]uint8
	s.setDefaults()

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "fee_moment":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.FeeMoment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fee_moment\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "balance":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.Balance.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"balance\"")
			}
		case "payout_balance":
			requiredBitSet[0] |= 1 << 5
			if err := func() error {
				if err := s.PayoutBalance.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"payout_balance\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 6
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "created_at":
			requiredBitSet[0] |= 1 << 7
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.CreatedAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"created_at\"")
			}
		case "expires_at":
			requiredBitSet[1] |= 1 << 0
			if err := func() error {
				v, err := json.DecodeDateTime(d)
				s.ExpiresAt = v
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"expires_at\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "test":
			requiredBitSet[1] |= 1 << 2
			if err := func() error {
				if err := s.Test.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"test\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SafeDeal")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [2]uint8{
		0b11110111,
		0b00000101,
	} {
		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(jsonFieldsNameOfSafeDeal) {
					name = jsonFieldsNameOfSafeDeal[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 *SafeDeal) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SafeDeal) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SafeDealBalance) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SafeDealBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfSafeDealBalance = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes SafeDealBalance from json.
func (s *SafeDealBalance) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SafeDealBalance to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SafeDealBalance")
	}
	// 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(jsonFieldsNameOfSafeDealBalance) {
					name = jsonFieldsNameOfSafeDealBalance[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 *SafeDealBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SafeDealBalance) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SafeDealPayoutBalance) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SafeDealPayoutBalance) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfSafeDealPayoutBalance = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes SafeDealPayoutBalance from json.
func (s *SafeDealPayoutBalance) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SafeDealPayoutBalance to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SafeDealPayoutBalance")
	}
	// 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(jsonFieldsNameOfSafeDealPayoutBalance) {
					name = jsonFieldsNameOfSafeDealPayoutBalance[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 *SafeDealPayoutBalance) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SafeDealPayoutBalance) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SafeDealRequest) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SafeDealRequest) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("fee_moment")
		s.FeeMoment.Encode(e)
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
}

var jsonFieldsNameOfSafeDealRequest = [4]string{
	0: "type",
	1: "fee_moment",
	2: "metadata",
	3: "description",
}

// Decode decodes SafeDealRequest from json.
func (s *SafeDealRequest) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SafeDealRequest to nil")
	}
	var requiredBitSet [1]uint8
	s.setDefaults()

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "fee_moment":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.FeeMoment.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"fee_moment\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SafeDealRequest")
	}
	// 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(jsonFieldsNameOfSafeDealRequest) {
					name = jsonFieldsNameOfSafeDealRequest[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 *SafeDealRequest) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SafeDealRequest) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SavePaymentMethodAttribute as json.
func (s SavePaymentMethodAttribute) Encode(e *jx.Encoder) {
	unwrapped := bool(s)

	e.Bool(unwrapped)
}

// Decode decodes SavePaymentMethodAttribute from json.
func (s *SavePaymentMethodAttribute) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodAttribute to nil")
	}
	var unwrapped bool
	if err := func() error {
		v, err := d.Bool()
		unwrapped = bool(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SavePaymentMethodAttribute(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SavePaymentMethodAttribute) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodAttribute) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SavePaymentMethodBankCard) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SavePaymentMethodBankCard) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("saved")
		e.Bool(s.Saved)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		e.FieldStart("holder")
		s.Holder.Encode(e)
	}
	{
		if s.Title.Set {
			e.FieldStart("title")
			s.Title.Encode(e)
		}
	}
	{
		if s.Confirmation.Set {
			e.FieldStart("confirmation")
			s.Confirmation.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfSavePaymentMethodBankCard = [8]string{
	0: "type",
	1: "id",
	2: "saved",
	3: "status",
	4: "holder",
	5: "title",
	6: "confirmation",
	7: "card",
}

// Decode decodes SavePaymentMethodBankCard from json.
func (s *SavePaymentMethodBankCard) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodBankCard to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "saved":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Bool()
				s.Saved = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"saved\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "holder":
			requiredBitSet[0] |= 1 << 4
			if err := func() error {
				if err := s.Holder.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"holder\"")
			}
		case "title":
			if err := func() error {
				s.Title.Reset()
				if err := s.Title.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"title\"")
			}
		case "confirmation":
			if err := func() error {
				s.Confirmation.Reset()
				if err := s.Confirmation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SavePaymentMethodBankCard")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00011111,
	} {
		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(jsonFieldsNameOfSavePaymentMethodBankCard) {
					name = jsonFieldsNameOfSavePaymentMethodBankCard[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 *SavePaymentMethodBankCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodBankCard) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SavePaymentMethodBankCardConfirmation as json.
func (s SavePaymentMethodBankCardConfirmation) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s SavePaymentMethodBankCardConfirmation) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case PaymentMethodsConfirmationRedirectSavePaymentMethodBankCardConfirmation:
		e.FieldStart("type")
		e.Str("redirect")
		{
			s := s.PaymentMethodsConfirmationRedirect
			{
				e.FieldStart("confirmation_url")
				e.Str(s.ConfirmationURL)
			}
			{
				if s.Enforce.Set {
					e.FieldStart("enforce")
					s.Enforce.Encode(e)
				}
			}
			{
				if s.ReturnURL.Set {
					e.FieldStart("return_url")
					s.ReturnURL.Encode(e)
				}
			}
		}
	}
}

// Decode decodes SavePaymentMethodBankCardConfirmation from json.
func (s *SavePaymentMethodBankCardConfirmation) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodBankCardConfirmation to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "redirect":
					s.Type = PaymentMethodsConfirmationRedirectSavePaymentMethodBankCardConfirmation
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case PaymentMethodsConfirmationRedirectSavePaymentMethodBankCardConfirmation:
		if err := s.PaymentMethodsConfirmationRedirect.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SavePaymentMethodBankCardConfirmation) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodBankCardConfirmation) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SavePaymentMethodBankCardHolder) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SavePaymentMethodBankCardHolder) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		s.AccountID.Encode(e)
	}
	{
		if s.GatewayID.Set {
			e.FieldStart("gateway_id")
			s.GatewayID.Encode(e)
		}
	}
}

var jsonFieldsNameOfSavePaymentMethodBankCardHolder = [2]string{
	0: "account_id",
	1: "gateway_id",
}

// Decode decodes SavePaymentMethodBankCardHolder from json.
func (s *SavePaymentMethodBankCardHolder) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodBankCardHolder to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.AccountID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "gateway_id":
			if err := func() error {
				s.GatewayID.Reset()
				if err := s.GatewayID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gateway_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SavePaymentMethodBankCardHolder")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfSavePaymentMethodBankCardHolder) {
					name = jsonFieldsNameOfSavePaymentMethodBankCardHolder[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 *SavePaymentMethodBankCardHolder) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodBankCardHolder) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SavePaymentMethodDataBankCard) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SavePaymentMethodDataBankCard) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Holder.Set {
			e.FieldStart("holder")
			s.Holder.Encode(e)
		}
	}
	{
		if s.ClientIP.Set {
			e.FieldStart("client_ip")
			s.ClientIP.Encode(e)
		}
	}
	{
		if s.Confirmation.Set {
			e.FieldStart("confirmation")
			s.Confirmation.Encode(e)
		}
	}
	{
		if s.Card.Set {
			e.FieldStart("card")
			s.Card.Encode(e)
		}
	}
}

var jsonFieldsNameOfSavePaymentMethodDataBankCard = [5]string{
	0: "type",
	1: "holder",
	2: "client_ip",
	3: "confirmation",
	4: "card",
}

// Decode decodes SavePaymentMethodDataBankCard from json.
func (s *SavePaymentMethodDataBankCard) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodDataBankCard to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "holder":
			if err := func() error {
				s.Holder.Reset()
				if err := s.Holder.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"holder\"")
			}
		case "client_ip":
			if err := func() error {
				s.ClientIP.Reset()
				if err := s.ClientIP.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"client_ip\"")
			}
		case "confirmation":
			if err := func() error {
				s.Confirmation.Reset()
				if err := s.Confirmation.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"confirmation\"")
			}
		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\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SavePaymentMethodDataBankCard")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfSavePaymentMethodDataBankCard) {
					name = jsonFieldsNameOfSavePaymentMethodDataBankCard[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 *SavePaymentMethodDataBankCard) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodDataBankCard) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SavePaymentMethodDataBankCardHolder) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SavePaymentMethodDataBankCardHolder) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("gateway_id")
		s.GatewayID.Encode(e)
	}
}

var jsonFieldsNameOfSavePaymentMethodDataBankCardHolder = [1]string{
	0: "gateway_id",
}

// Decode decodes SavePaymentMethodDataBankCardHolder from json.
func (s *SavePaymentMethodDataBankCardHolder) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodDataBankCardHolder to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "gateway_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.GatewayID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"gateway_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SavePaymentMethodDataBankCardHolder")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfSavePaymentMethodDataBankCardHolder) {
					name = jsonFieldsNameOfSavePaymentMethodDataBankCardHolder[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 *SavePaymentMethodDataBankCardHolder) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodDataBankCardHolder) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SavePaymentMethodDataBankCardType as json.
func (s SavePaymentMethodDataBankCardType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes SavePaymentMethodDataBankCardType from json.
func (s *SavePaymentMethodDataBankCardType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodDataBankCardType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch SavePaymentMethodDataBankCardType(v) {
	case SavePaymentMethodDataBankCardTypeBankCard:
		*s = SavePaymentMethodDataBankCardTypeBankCard
	default:
		*s = SavePaymentMethodDataBankCardType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SavePaymentMethodDataBankCardType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodDataBankCardType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SavePaymentMethodType as json.
func (s SavePaymentMethodType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes SavePaymentMethodType from json.
func (s *SavePaymentMethodType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SavePaymentMethodType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch SavePaymentMethodType(v) {
	case SavePaymentMethodTypeBankCard:
		*s = SavePaymentMethodTypeBankCard
	default:
		*s = SavePaymentMethodType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SavePaymentMethodType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SavePaymentMethodType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Sbp) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Sbp) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("phone")
		e.Str(s.Phone)
	}
	{
		e.FieldStart("bank_id")
		e.Str(s.BankID)
	}
}

var jsonFieldsNameOfSbp = [3]string{
	0: "type",
	1: "phone",
	2: "bank_id",
}

// Decode decodes Sbp from json.
func (s *Sbp) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Sbp to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "phone":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Phone = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"phone\"")
			}
		case "bank_id":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.BankID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Sbp")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfSbp) {
					name = jsonFieldsNameOfSbp[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 *Sbp) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Sbp) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SbpBankBic as json.
func (s SbpBankBic) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes SbpBankBic from json.
func (s *SbpBankBic) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBankBic to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SbpBankBic(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SbpBankBic) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBankBic) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SbpBankId as json.
func (s SbpBankId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes SbpBankId from json.
func (s *SbpBankId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBankId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SbpBankId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SbpBankId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBankId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SbpBanksGetInternalServerError as json.
func (s *SbpBanksGetInternalServerError) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes SbpBanksGetInternalServerError from json.
func (s *SbpBanksGetInternalServerError) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBanksGetInternalServerError to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SbpBanksGetInternalServerError(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SbpBanksGetInternalServerError) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBanksGetInternalServerError) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SbpBanksGetOK) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SbpBanksGetOK) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
}

var jsonFieldsNameOfSbpBanksGetOK = [2]string{
	0: "type",
	1: "items",
}

// Decode decodes SbpBanksGetOK from json.
func (s *SbpBanksGetOK) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBanksGetOK to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]SbpParticipantBank, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem SbpParticipantBank
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SbpBanksGetOK")
	}
	// 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(jsonFieldsNameOfSbpBanksGetOK) {
					name = jsonFieldsNameOfSbpBanksGetOK[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 *SbpBanksGetOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBanksGetOK) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SbpBanksGetOKType as json.
func (s SbpBanksGetOKType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes SbpBanksGetOKType from json.
func (s *SbpBanksGetOKType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBanksGetOKType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch SbpBanksGetOKType(v) {
	case SbpBanksGetOKTypeList:
		*s = SbpBanksGetOKTypeList
	default:
		*s = SbpBanksGetOKType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SbpBanksGetOKType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBanksGetOKType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SbpBanksGetTooManyRequests as json.
func (s *SbpBanksGetTooManyRequests) Encode(e *jx.Encoder) {
	unwrapped := (*TooManyRequests)(s)

	unwrapped.Encode(e)
}

// Decode decodes SbpBanksGetTooManyRequests from json.
func (s *SbpBanksGetTooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpBanksGetTooManyRequests to nil")
	}
	var unwrapped TooManyRequests
	if err := func() error {
		if err := unwrapped.Decode(d); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SbpBanksGetTooManyRequests(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *SbpBanksGetTooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpBanksGetTooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SbpParticipantBank) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SbpParticipantBank) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("bank_id")
		s.BankID.Encode(e)
	}
	{
		e.FieldStart("name")
		e.Str(s.Name)
	}
	{
		e.FieldStart("bic")
		s.Bic.Encode(e)
	}
}

var jsonFieldsNameOfSbpParticipantBank = [3]string{
	0: "bank_id",
	1: "name",
	2: "bic",
}

// Decode decodes SbpParticipantBank from json.
func (s *SbpParticipantBank) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpParticipantBank to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "bank_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.BankID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_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\"")
			}
		case "bic":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Bic.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bic\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SbpParticipantBank")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfSbpParticipantBank) {
					name = jsonFieldsNameOfSbpParticipantBank[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 *SbpParticipantBank) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpParticipantBank) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SbpPayerBankDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SbpPayerBankDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("bank_id")
		s.BankID.Encode(e)
	}
	{
		e.FieldStart("bic")
		e.Str(s.Bic)
	}
}

var jsonFieldsNameOfSbpPayerBankDetails = [2]string{
	0: "bank_id",
	1: "bic",
}

// Decode decodes SbpPayerBankDetails from json.
func (s *SbpPayerBankDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpPayerBankDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "bank_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.BankID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bank_id\"")
			}
		case "bic":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.Bic = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"bic\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SbpPayerBankDetails")
	}
	// 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(jsonFieldsNameOfSbpPayerBankDetails) {
					name = jsonFieldsNameOfSbpPayerBankDetails[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 *SbpPayerBankDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpPayerBankDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SbpPayoutRecipientPersonalDataRequest) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SbpPayoutRecipientPersonalDataRequest) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
	{
		e.FieldStart("last_name")
		s.LastName.Encode(e)
	}
	{
		e.FieldStart("first_name")
		s.FirstName.Encode(e)
	}
	{
		if s.MiddleName.Set {
			e.FieldStart("middle_name")
			s.MiddleName.Encode(e)
		}
	}
}

var jsonFieldsNameOfSbpPayoutRecipientPersonalDataRequest = [5]string{
	0: "type",
	1: "metadata",
	2: "last_name",
	3: "first_name",
	4: "middle_name",
}

// Decode decodes SbpPayoutRecipientPersonalDataRequest from json.
func (s *SbpPayoutRecipientPersonalDataRequest) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpPayoutRecipientPersonalDataRequest to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		case "last_name":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.LastName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"last_name\"")
			}
		case "first_name":
			requiredBitSet[0] |= 1 << 3
			if err := func() error {
				if err := s.FirstName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"first_name\"")
			}
		case "middle_name":
			if err := func() error {
				s.MiddleName.Reset()
				if err := s.MiddleName.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"middle_name\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SbpPayoutRecipientPersonalDataRequest")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00001101,
	} {
		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(jsonFieldsNameOfSbpPayoutRecipientPersonalDataRequest) {
					name = jsonFieldsNameOfSbpPayoutRecipientPersonalDataRequest[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 *SbpPayoutRecipientPersonalDataRequest) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpPayoutRecipientPersonalDataRequest) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SbpRefundMethod) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SbpRefundMethod) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		if s.SbpOperationID.Set {
			e.FieldStart("sbp_operation_id")
			s.SbpOperationID.Encode(e)
		}
	}
}

var jsonFieldsNameOfSbpRefundMethod = [2]string{
	0: "type",
	1: "sbp_operation_id",
}

// Decode decodes SbpRefundMethod from json.
func (s *SbpRefundMethod) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SbpRefundMethod to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "sbp_operation_id":
			if err := func() error {
				s.SbpOperationID.Reset()
				if err := s.SbpOperationID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"sbp_operation_id\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SbpRefundMethod")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfSbpRefundMethod) {
					name = jsonFieldsNameOfSbpRefundMethod[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 *SbpRefundMethod) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SbpRefundMethod) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SelfEmployedId as json.
func (s SelfEmployedId) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes SelfEmployedId from json.
func (s *SelfEmployedId) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SelfEmployedId to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = SelfEmployedId(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SelfEmployedId) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SelfEmployedId) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Settlement) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Settlement) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfSettlement = [2]string{
	0: "type",
	1: "amount",
}

// Decode decodes Settlement from json.
func (s *Settlement) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Settlement to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Settlement")
	}
	// 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(jsonFieldsNameOfSettlement) {
					name = jsonFieldsNameOfSettlement[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 *Settlement) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Settlement) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SettlementAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SettlementAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfSettlementAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes SettlementAmount from json.
func (s *SettlementAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SettlementAmount")
	}
	// 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(jsonFieldsNameOfSettlementAmount) {
					name = jsonFieldsNameOfSettlementAmount[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 *SettlementAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementItemType as json.
func (s SettlementItemType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes SettlementItemType from json.
func (s *SettlementItemType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementItemType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch SettlementItemType(v) {
	case SettlementItemTypePayout:
		*s = SettlementItemTypePayout
	default:
		*s = SettlementItemType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementItemType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementItemType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementPaymentArray as json.
func (s SettlementPaymentArray) Encode(e *jx.Encoder) {
	unwrapped := []SettlementPaymentArrayItem(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes SettlementPaymentArray from json.
func (s *SettlementPaymentArray) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPaymentArray to nil")
	}
	var unwrapped []SettlementPaymentArrayItem
	if err := func() error {
		unwrapped = make([]SettlementPaymentArrayItem, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem SettlementPaymentArrayItem
			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 = SettlementPaymentArray(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementPaymentArray) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPaymentArray) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementPaymentArrayItem as json.
func (s SettlementPaymentArrayItem) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s SettlementPaymentArrayItem) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SettlementPayoutPaymentSettlementPaymentArrayItem:
		e.FieldStart("type")
		e.Str("SettlementPayoutPayment")
		{
			s := s.SettlementPayoutPayment
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	}
}

// Decode decodes SettlementPaymentArrayItem from json.
func (s *SettlementPaymentArrayItem) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPaymentArrayItem to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SettlementPayoutPayment":
					s.Type = SettlementPayoutPaymentSettlementPaymentArrayItem
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SettlementPayoutPaymentSettlementPaymentArrayItem:
		if err := s.SettlementPayoutPayment.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementPaymentArrayItem) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPaymentArrayItem) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SettlementPayoutPayment) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SettlementPayoutPayment) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfSettlementPayoutPayment = [2]string{
	0: "type",
	1: "amount",
}

// Decode decodes SettlementPayoutPayment from json.
func (s *SettlementPayoutPayment) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPayoutPayment to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SettlementPayoutPayment")
	}
	// 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(jsonFieldsNameOfSettlementPayoutPayment) {
					name = jsonFieldsNameOfSettlementPayoutPayment[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 *SettlementPayoutPayment) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPayoutPayment) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SettlementPayoutPaymentAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SettlementPayoutPaymentAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfSettlementPayoutPaymentAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes SettlementPayoutPaymentAmount from json.
func (s *SettlementPayoutPaymentAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPayoutPaymentAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SettlementPayoutPaymentAmount")
	}
	// 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(jsonFieldsNameOfSettlementPayoutPaymentAmount) {
					name = jsonFieldsNameOfSettlementPayoutPaymentAmount[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 *SettlementPayoutPaymentAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPayoutPaymentAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SettlementPayoutRefund) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SettlementPayoutRefund) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
}

var jsonFieldsNameOfSettlementPayoutRefund = [2]string{
	0: "type",
	1: "amount",
}

// Decode decodes SettlementPayoutRefund from json.
func (s *SettlementPayoutRefund) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPayoutRefund to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SettlementPayoutRefund")
	}
	// 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(jsonFieldsNameOfSettlementPayoutRefund) {
					name = jsonFieldsNameOfSettlementPayoutRefund[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 *SettlementPayoutRefund) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPayoutRefund) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *SettlementPayoutRefundAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *SettlementPayoutRefundAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfSettlementPayoutRefundAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes SettlementPayoutRefundAmount from json.
func (s *SettlementPayoutRefundAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementPayoutRefundAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode SettlementPayoutRefundAmount")
	}
	// 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(jsonFieldsNameOfSettlementPayoutRefundAmount) {
					name = jsonFieldsNameOfSettlementPayoutRefundAmount[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 *SettlementPayoutRefundAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementPayoutRefundAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementRefundArray as json.
func (s SettlementRefundArray) Encode(e *jx.Encoder) {
	unwrapped := []SettlementRefundArrayItem(s)

	e.ArrStart()
	for _, elem := range unwrapped {
		elem.Encode(e)
	}
	e.ArrEnd()
}

// Decode decodes SettlementRefundArray from json.
func (s *SettlementRefundArray) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementRefundArray to nil")
	}
	var unwrapped []SettlementRefundArrayItem
	if err := func() error {
		unwrapped = make([]SettlementRefundArrayItem, 0)
		if err := d.Arr(func(d *jx.Decoder) error {
			var elem SettlementRefundArrayItem
			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 = SettlementRefundArray(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementRefundArray) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementRefundArray) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementRefundArrayItem as json.
func (s SettlementRefundArrayItem) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

func (s SettlementRefundArrayItem) encodeFields(e *jx.Encoder) {
	switch s.Type {
	case SettlementPayoutRefundSettlementRefundArrayItem:
		e.FieldStart("type")
		e.Str("SettlementPayoutRefund")
		{
			s := s.SettlementPayoutRefund
			{
				e.FieldStart("amount")
				s.Amount.Encode(e)
			}
		}
	}
}

// Decode decodes SettlementRefundArrayItem from json.
func (s *SettlementRefundArrayItem) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementRefundArrayItem to nil")
	}
	// Sum type discriminator.
	if typ := d.Next(); typ != jx.Object {
		return errors.Errorf("unexpected json type %q", typ)
	}

	var found bool
	if err := d.Capture(func(d *jx.Decoder) error {
		return d.ObjBytes(func(d *jx.Decoder, key []byte) error {
			if found {
				return d.Skip()
			}
			switch string(key) {
			case "type":
				typ, err := d.Str()
				if err != nil {
					return err
				}
				switch typ {
				case "SettlementPayoutRefund":
					s.Type = SettlementPayoutRefundSettlementRefundArrayItem
					found = true
				default:
					return errors.Errorf("unknown type %s", typ)
				}
				return nil
			}
			return d.Skip()
		})
	}); err != nil {
		return errors.Wrap(err, "capture")
	}
	if !found {
		return errors.New("unable to detect sum type variant")
	}
	switch s.Type {
	case SettlementPayoutRefundSettlementRefundArrayItem:
		if err := s.SettlementPayoutRefund.Decode(d); err != nil {
			return err
		}
	default:
		return errors.Errorf("inferred invalid type: %s", s.Type)
	}
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementRefundArrayItem) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementRefundArrayItem) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes SettlementType as json.
func (s SettlementType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes SettlementType from json.
func (s *SettlementType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode SettlementType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch SettlementType(v) {
	case SettlementTypeCashless:
		*s = SettlementTypeCashless
	case SettlementTypePrepayment:
		*s = SettlementTypePrepayment
	case SettlementTypePostpayment:
		*s = SettlementTypePostpayment
	case SettlementTypeConsideration:
		*s = SettlementTypeConsideration
	default:
		*s = SettlementType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s SettlementType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SettlementType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes TaxSystemCode as json.
func (s TaxSystemCode) Encode(e *jx.Encoder) {
	unwrapped := int32(s)

	e.Int32(unwrapped)
}

// Decode decodes TaxSystemCode from json.
func (s *TaxSystemCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TaxSystemCode to nil")
	}
	var unwrapped int32
	if err := func() error {
		v, err := d.Int32()
		unwrapped = int32(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = TaxSystemCode(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s TaxSystemCode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaxSystemCode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes Test as json.
func (s Test) Encode(e *jx.Encoder) {
	unwrapped := bool(s)

	e.Bool(unwrapped)
}

// Decode decodes Test from json.
func (s *Test) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Test to nil")
	}
	var unwrapped bool
	if err := func() error {
		v, err := d.Bool()
		unwrapped = bool(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = Test(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s Test) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Test) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *ThreeDSecureDetails) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *ThreeDSecureDetails) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("applied")
		e.Bool(s.Applied)
	}
}

var jsonFieldsNameOfThreeDSecureDetails = [1]string{
	0: "applied",
}

// Decode decodes ThreeDSecureDetails from json.
func (s *ThreeDSecureDetails) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode ThreeDSecureDetails to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "applied":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Bool()
				s.Applied = bool(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"applied\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode ThreeDSecureDetails")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000001,
	} {
		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(jsonFieldsNameOfThreeDSecureDetails) {
					name = jsonFieldsNameOfThreeDSecureDetails[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 *ThreeDSecureDetails) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ThreeDSecureDetails) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TooManyRequests) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TooManyRequests) encodeFields(e *jx.Encoder) {
	{
		if s.Type.Set {
			e.FieldStart("type")
			s.Type.Encode(e)
		}
	}
	{
		if s.ID.Set {
			e.FieldStart("id")
			s.ID.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Parameter.Set {
			e.FieldStart("parameter")
			s.Parameter.Encode(e)
		}
	}
	{
		if s.RetryAfter.Set {
			e.FieldStart("retry_after")
			s.RetryAfter.Encode(e)
		}
	}
	{
		if s.Code.Set {
			e.FieldStart("code")
			s.Code.Encode(e)
		}
	}
}

var jsonFieldsNameOfTooManyRequests = [6]string{
	0: "type",
	1: "id",
	2: "description",
	3: "parameter",
	4: "retry_after",
	5: "code",
}

// Decode decodes TooManyRequests from json.
func (s *TooManyRequests) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TooManyRequests to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			if err := func() error {
				s.Type.Reset()
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "id":
			if err := func() error {
				s.ID.Reset()
				if err := s.ID.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "parameter":
			if err := func() error {
				s.Parameter.Reset()
				if err := s.Parameter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"parameter\"")
			}
		case "retry_after":
			if err := func() error {
				s.RetryAfter.Reset()
				if err := s.RetryAfter.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"retry_after\"")
			}
		case "code":
			if err := func() error {
				s.Code.Reset()
				if err := s.Code.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"code\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TooManyRequests")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *TooManyRequests) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TooManyRequests) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes TooManyRequestsCode as json.
func (s TooManyRequestsCode) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes TooManyRequestsCode from json.
func (s *TooManyRequestsCode) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TooManyRequestsCode to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch TooManyRequestsCode(v) {
	case TooManyRequestsCodeTooManyRequests:
		*s = TooManyRequestsCodeTooManyRequests
	default:
		*s = TooManyRequestsCode(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s TooManyRequestsCode) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TooManyRequestsCode) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes TooManyRequestsType as json.
func (s TooManyRequestsType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes TooManyRequestsType from json.
func (s *TooManyRequestsType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TooManyRequestsType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch TooManyRequestsType(v) {
	case TooManyRequestsTypeError:
		*s = TooManyRequestsTypeError
	default:
		*s = TooManyRequestsType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s TooManyRequestsType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TooManyRequestsType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Transfer) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Transfer) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		e.Str(s.AccountID)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		e.FieldStart("status")
		s.Status.Encode(e)
	}
	{
		if s.PlatformFeeAmount.Set {
			e.FieldStart("platform_fee_amount")
			s.PlatformFeeAmount.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfTransfer = [6]string{
	0: "account_id",
	1: "amount",
	2: "status",
	3: "platform_fee_amount",
	4: "description",
	5: "metadata",
}

// Decode decodes Transfer from json.
func (s *Transfer) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Transfer to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.AccountID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "status":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				if err := s.Status.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"status\"")
			}
		case "platform_fee_amount":
			if err := func() error {
				s.PlatformFeeAmount.Reset()
				if err := s.PlatformFeeAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"platform_fee_amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Transfer")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfTransfer) {
					name = jsonFieldsNameOfTransfer[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 *Transfer) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Transfer) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferAmount from json.
func (s *TransferAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferAmount")
	}
	// 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(jsonFieldsNameOfTransferAmount) {
					name = jsonFieldsNameOfTransferAmount[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 *TransferAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferData) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferData) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		e.Str(s.AccountID)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.PlatformFeeAmount.Set {
			e.FieldStart("platform_fee_amount")
			s.PlatformFeeAmount.Encode(e)
		}
	}
}

var jsonFieldsNameOfTransferData = [3]string{
	0: "account_id",
	1: "amount",
	2: "platform_fee_amount",
}

// Decode decodes TransferData from json.
func (s *TransferData) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferData to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.AccountID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "platform_fee_amount":
			if err := func() error {
				s.PlatformFeeAmount.Reset()
				if err := s.PlatformFeeAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"platform_fee_amount\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferData")
	}
	// 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(jsonFieldsNameOfTransferData) {
					name = jsonFieldsNameOfTransferData[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 *TransferData) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferData) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferDataAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferDataAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferDataAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferDataAmount from json.
func (s *TransferDataAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferDataAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferDataAmount")
	}
	// 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(jsonFieldsNameOfTransferDataAmount) {
					name = jsonFieldsNameOfTransferDataAmount[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 *TransferDataAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferDataAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferDataPayment) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferDataPayment) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("account_id")
		e.Str(s.AccountID)
	}
	{
		e.FieldStart("amount")
		s.Amount.Encode(e)
	}
	{
		if s.PlatformFeeAmount.Set {
			e.FieldStart("platform_fee_amount")
			s.PlatformFeeAmount.Encode(e)
		}
	}
	{
		if s.Description.Set {
			e.FieldStart("description")
			s.Description.Encode(e)
		}
	}
	{
		if s.Metadata.Set {
			e.FieldStart("metadata")
			s.Metadata.Encode(e)
		}
	}
}

var jsonFieldsNameOfTransferDataPayment = [5]string{
	0: "account_id",
	1: "amount",
	2: "platform_fee_amount",
	3: "description",
	4: "metadata",
}

// Decode decodes TransferDataPayment from json.
func (s *TransferDataPayment) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferDataPayment to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "account_id":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.AccountID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_id\"")
			}
		case "amount":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Amount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"amount\"")
			}
		case "platform_fee_amount":
			if err := func() error {
				s.PlatformFeeAmount.Reset()
				if err := s.PlatformFeeAmount.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"platform_fee_amount\"")
			}
		case "description":
			if err := func() error {
				s.Description.Reset()
				if err := s.Description.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"description\"")
			}
		case "metadata":
			if err := func() error {
				s.Metadata.Reset()
				if err := s.Metadata.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"metadata\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferDataPayment")
	}
	// 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(jsonFieldsNameOfTransferDataPayment) {
					name = jsonFieldsNameOfTransferDataPayment[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 *TransferDataPayment) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferDataPayment) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferDataPaymentAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferDataPaymentAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferDataPaymentAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferDataPaymentAmount from json.
func (s *TransferDataPaymentAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferDataPaymentAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferDataPaymentAmount")
	}
	// 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(jsonFieldsNameOfTransferDataPaymentAmount) {
					name = jsonFieldsNameOfTransferDataPaymentAmount[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 *TransferDataPaymentAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferDataPaymentAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferDataPaymentPlatformFeeAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferDataPaymentPlatformFeeAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferDataPaymentPlatformFeeAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferDataPaymentPlatformFeeAmount from json.
func (s *TransferDataPaymentPlatformFeeAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferDataPaymentPlatformFeeAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferDataPaymentPlatformFeeAmount")
	}
	// 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(jsonFieldsNameOfTransferDataPaymentPlatformFeeAmount) {
					name = jsonFieldsNameOfTransferDataPaymentPlatformFeeAmount[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 *TransferDataPaymentPlatformFeeAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferDataPaymentPlatformFeeAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferDataPlatformFeeAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferDataPlatformFeeAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferDataPlatformFeeAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferDataPlatformFeeAmount from json.
func (s *TransferDataPlatformFeeAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferDataPlatformFeeAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferDataPlatformFeeAmount")
	}
	// 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(jsonFieldsNameOfTransferDataPlatformFeeAmount) {
					name = jsonFieldsNameOfTransferDataPlatformFeeAmount[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 *TransferDataPlatformFeeAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferDataPlatformFeeAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *TransferPlatformFeeAmount) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *TransferPlatformFeeAmount) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("value")
		e.Str(s.Value)
	}
	{
		e.FieldStart("currency")
		s.Currency.Encode(e)
	}
}

var jsonFieldsNameOfTransferPlatformFeeAmount = [2]string{
	0: "value",
	1: "currency",
}

// Decode decodes TransferPlatformFeeAmount from json.
func (s *TransferPlatformFeeAmount) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferPlatformFeeAmount to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "value":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				v, err := d.Str()
				s.Value = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"value\"")
			}
		case "currency":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Currency.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"currency\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode TransferPlatformFeeAmount")
	}
	// 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(jsonFieldsNameOfTransferPlatformFeeAmount) {
					name = jsonFieldsNameOfTransferPlatformFeeAmount[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 *TransferPlatformFeeAmount) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferPlatformFeeAmount) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes TransferStatus as json.
func (s TransferStatus) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes TransferStatus from json.
func (s *TransferStatus) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode TransferStatus to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch TransferStatus(v) {
	case TransferStatusPending:
		*s = TransferStatusPending
	case TransferStatusWaitingForCapture:
		*s = TransferStatusWaitingForCapture
	case TransferStatusSucceeded:
		*s = TransferStatusSucceeded
	case TransferStatusCanceled:
		*s = TransferStatusCanceled
	default:
		*s = TransferStatus(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s TransferStatus) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TransferStatus) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *Webhook) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *Webhook) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("id")
		e.Str(s.ID)
	}
	{
		e.FieldStart("event")
		s.Event.Encode(e)
	}
	{
		e.FieldStart("url")
		e.Str(s.URL)
	}
}

var jsonFieldsNameOfWebhook = [3]string{
	0: "id",
	1: "event",
	2: "url",
}

// Decode decodes Webhook from json.
func (s *Webhook) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode Webhook 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.Str()
				s.ID = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"id\"")
			}
		case "event":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				if err := s.Event.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"event\"")
			}
		case "url":
			requiredBitSet[0] |= 1 << 2
			if err := func() error {
				v, err := d.Str()
				s.URL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode Webhook")
	}
	// Validate required fields.
	var failures []validate.FieldError
	for i, mask := range [1]uint8{
		0b00000111,
	} {
		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(jsonFieldsNameOfWebhook) {
					name = jsonFieldsNameOfWebhook[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 *Webhook) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Webhook) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes WebhookEvent as json.
func (s WebhookEvent) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes WebhookEvent from json.
func (s *WebhookEvent) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhookEvent to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch WebhookEvent(v) {
	case WebhookEventPaymentWaitingForCapture:
		*s = WebhookEventPaymentWaitingForCapture
	case WebhookEventPaymentSucceeded:
		*s = WebhookEventPaymentSucceeded
	case WebhookEventPaymentCanceled:
		*s = WebhookEventPaymentCanceled
	case WebhookEventRefundSucceeded:
		*s = WebhookEventRefundSucceeded
	default:
		*s = WebhookEvent(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhookEvent) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookEvent) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhookList) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhookList) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("items")
		e.ArrStart()
		for _, elem := range s.Items {
			elem.Encode(e)
		}
		e.ArrEnd()
	}
}

var jsonFieldsNameOfWebhookList = [2]string{
	0: "type",
	1: "items",
}

// Decode decodes WebhookList from json.
func (s *WebhookList) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhookList to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "items":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				s.Items = make([]Webhook, 0)
				if err := d.Arr(func(d *jx.Decoder) error {
					var elem Webhook
					if err := elem.Decode(d); err != nil {
						return err
					}
					s.Items = append(s.Items, elem)
					return nil
				}); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"items\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode WebhookList")
	}
	// 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(jsonFieldsNameOfWebhookList) {
					name = jsonFieldsNameOfWebhookList[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 *WebhookList) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookList) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes WebhookListType as json.
func (s WebhookListType) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes WebhookListType from json.
func (s *WebhookListType) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhookListType to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch WebhookListType(v) {
	case WebhookListTypeList:
		*s = WebhookListTypeList
	default:
		*s = WebhookListType(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhookListType) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhookListType) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhooksPostReq) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhooksPostReq) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("event")
		s.Event.Encode(e)
	}
	{
		e.FieldStart("url")
		e.Str(s.URL)
	}
}

var jsonFieldsNameOfWebhooksPostReq = [2]string{
	0: "event",
	1: "url",
}

// Decode decodes WebhooksPostReq from json.
func (s *WebhooksPostReq) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhooksPostReq to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "event":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Event.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"event\"")
			}
		case "url":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.URL = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"url\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode WebhooksPostReq")
	}
	// 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(jsonFieldsNameOfWebhooksPostReq) {
					name = jsonFieldsNameOfWebhooksPostReq[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 *WebhooksPostReq) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhooksPostReq) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes WebhooksPostReqEvent as json.
func (s WebhooksPostReqEvent) Encode(e *jx.Encoder) {
	e.Str(string(s))
}

// Decode decodes WebhooksPostReqEvent from json.
func (s *WebhooksPostReqEvent) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhooksPostReqEvent to nil")
	}
	v, err := d.StrBytes()
	if err != nil {
		return err
	}
	// Try to use constant string.
	switch WebhooksPostReqEvent(v) {
	case WebhooksPostReqEventPaymentWaitingForCapture:
		*s = WebhooksPostReqEventPaymentWaitingForCapture
	case WebhooksPostReqEventPaymentSucceeded:
		*s = WebhooksPostReqEventPaymentSucceeded
	case WebhooksPostReqEventPaymentCanceled:
		*s = WebhooksPostReqEventPaymentCanceled
	case WebhooksPostReqEventRefundSucceeded:
		*s = WebhooksPostReqEventRefundSucceeded
	default:
		*s = WebhooksPostReqEvent(v)
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s WebhooksPostReqEvent) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhooksPostReqEvent) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *WebhooksWebhookIDDeleteOK) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *WebhooksWebhookIDDeleteOK) encodeFields(e *jx.Encoder) {
}

var jsonFieldsNameOfWebhooksWebhookIDDeleteOK = [0]string{}

// Decode decodes WebhooksWebhookIDDeleteOK from json.
func (s *WebhooksWebhookIDDeleteOK) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode WebhooksWebhookIDDeleteOK to nil")
	}

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		default:
			return d.Skip()
		}
	}); err != nil {
		return errors.Wrap(err, "decode WebhooksWebhookIDDeleteOK")
	}

	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s *WebhooksWebhookIDDeleteOK) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WebhooksWebhookIDDeleteOK) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode implements json.Marshaler.
func (s *YooMoney) Encode(e *jx.Encoder) {
	e.ObjStart()
	s.encodeFields(e)
	e.ObjEnd()
}

// encodeFields encodes fields.
func (s *YooMoney) encodeFields(e *jx.Encoder) {
	{
		e.FieldStart("type")
		s.Type.Encode(e)
	}
	{
		e.FieldStart("account_number")
		e.Str(s.AccountNumber)
	}
}

var jsonFieldsNameOfYooMoney = [2]string{
	0: "type",
	1: "account_number",
}

// Decode decodes YooMoney from json.
func (s *YooMoney) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode YooMoney to nil")
	}
	var requiredBitSet [1]uint8

	if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
		switch string(k) {
		case "type":
			requiredBitSet[0] |= 1 << 0
			if err := func() error {
				if err := s.Type.Decode(d); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"type\"")
			}
		case "account_number":
			requiredBitSet[0] |= 1 << 1
			if err := func() error {
				v, err := d.Str()
				s.AccountNumber = string(v)
				if err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return errors.Wrap(err, "decode field \"account_number\"")
			}
		default:
			return d.Skip()
		}
		return nil
	}); err != nil {
		return errors.Wrap(err, "decode YooMoney")
	}
	// 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(jsonFieldsNameOfYooMoney) {
					name = jsonFieldsNameOfYooMoney[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 *YooMoney) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *YooMoney) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}

// Encode encodes YooMoneyAccountNumber as json.
func (s YooMoneyAccountNumber) Encode(e *jx.Encoder) {
	unwrapped := string(s)

	e.Str(unwrapped)
}

// Decode decodes YooMoneyAccountNumber from json.
func (s *YooMoneyAccountNumber) Decode(d *jx.Decoder) error {
	if s == nil {
		return errors.New("invalid: unable to decode YooMoneyAccountNumber to nil")
	}
	var unwrapped string
	if err := func() error {
		v, err := d.Str()
		unwrapped = string(v)
		if err != nil {
			return err
		}
		return nil
	}(); err != nil {
		return errors.Wrap(err, "alias")
	}
	*s = YooMoneyAccountNumber(unwrapped)
	return nil
}

// MarshalJSON implements stdjson.Marshaler.
func (s YooMoneyAccountNumber) MarshalJSON() ([]byte, error) {
	e := jx.Encoder{}
	s.Encode(&e)
	return e.Bytes(), nil
}

// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *YooMoneyAccountNumber) UnmarshalJSON(data []byte) error {
	d := jx.DecodeBytes(data)
	return s.Decode(d)
}