// Code generated by ogen, DO NOT EDIT.

package gen

import (
	"fmt"

	"github.com/go-faster/errors"
	"github.com/ogen-go/ogen/validate"
)

func (s *AirlineLeg) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     3,
			MinLengthSet:  true,
			MaxLength:     3,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[A-Z]{3}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.DepartureAirport)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "departure_airport",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     3,
			MinLengthSet:  true,
			MaxLength:     3,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[A-Z]{3}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.DestinationAirport)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "destination_airport",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CarrierCode.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     2,
					MinLengthSet:  true,
					MaxLength:     3,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "carrier_code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *AirlinePassenger) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     1,
			MinLengthSet:  true,
			MaxLength:     64,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.FirstName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     1,
			MinLengthSet:  true,
			MaxLength:     64,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.LastName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last_name",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *B2bSberbankCalculatedVatData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Rate.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "rate",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *B2bSberbankCalculatedVatDataAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s B2bSberbankCalculatedVatDataRate) Validate() error {
	switch s {
	case "5":
		return nil
	case "7":
		return nil
	case "10":
		return nil
	case "20":
		return nil
	case "22":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *B2bSberbankMixedVatData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *B2bSberbankMixedVatDataAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *B2bSberbankPayerBankDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     800,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.FullName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "full_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     160,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ShortName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "short_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     500,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Address)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "address",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{10}|\\d{12}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Inn)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "inn",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     1,
			MinLengthSet:  true,
			MaxLength:     350,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BankName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     1,
			MinLengthSet:  true,
			MaxLength:     140,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BankBranch)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_branch",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{9}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BankBik)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_bik",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{20}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Account)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Kpp.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["\\d{9}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "kpp",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *B2bSberbankUntaxedVatData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s B2bSberbankVatDataType) Validate() error {
	switch s {
	case "calculated":
		return nil
	case "untaxed":
		return nil
	case "mixed":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *BadRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Type.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Code.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s BadRequestCode) Validate() error {
	switch s {
	case "invalid_request":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s BadRequestType) Validate() error {
	switch s {
	case "error":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *BankCardData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.First6.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first6",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Last4.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last4",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.ExpiryYear.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "expiry_year",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.CardType.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Source.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "source",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s BankCardDataSource) Validate() error {
	switch s {
	case "apple_pay":
		return nil
	case "google_pay":
		return nil
	case "mir_pay":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s BankCardExpiryYear) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["[0-9]{4}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s BankCardFirst6) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["[0-9]{6}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s BankCardHolderName) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["[a-zA-Z '-]{0,26}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s BankCardLast4) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["[0-9]{4}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s BankCardType) Validate() error {
	switch s {
	case "MasterCard":
		return nil
	case "Visa":
		return nil
	case "Mir":
		return nil
	case "UnionPay":
		return nil
	case "JCB":
		return nil
	case "AmericanExpress":
		return nil
	case "DinersClub":
		return nil
	case "DiscoverCard":
		return nil
	case "InstaPayment":
		return nil
	case "InstaPaymentTM":
		return nil
	case "Laser":
		return nil
	case "Dankort":
		return nil
	case "Solo":
		return nil
	case "Switch":
		return nil
	case "Unknown":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *CardDataForPayoutDestination) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{16,19}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Number)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "number",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *CardRequestData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{14,19}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Number)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "number",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{4}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ExpiryYear)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "expiry_year",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{2}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ExpiryMonth)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "expiry_month",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Cardholder.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "cardholder",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *Confirmation) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationDataEmbedded) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationDataExternal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationDataMobileApplication) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     2048,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ReturnURL)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationDataQr) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReturnURL.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     2048,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationDataRedirect) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.ReturnURL.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ConfirmationDataType) Validate() error {
	switch s {
	case "redirect":
		return nil
	case "external":
		return nil
	case "qr":
		return nil
	case "embedded":
		return nil
	case "mobile_application":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *ConfirmationEmbedded) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationMobileApplication) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationQr) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfirmationRedirect) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReturnURL.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ConfirmationType) Validate() error {
	switch s {
	case "redirect":
		return nil
	case "external":
		return nil
	case "qr":
		return nil
	case "embedded":
		return nil
	case "mobile_application":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s CurrencyCode) Validate() error {
	switch s {
	case "RUB":
		return nil
	case "EUR":
		return nil
	case "USD":
		return nil
	case "KZT":
		return nil
	case "BYN":
		return nil
	case "UAH":
		return nil
	case "UZS":
		return nil
	case "TRY":
		return nil
	case "INR":
		return nil
	case "MDL":
		return nil
	case "AZN":
		return nil
	case "AMD":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s DealId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     50,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s DealStatus) Validate() error {
	switch s {
	case "opened":
		return nil
	case "closed":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s DealType) Validate() error {
	switch s {
	case "safe_deal":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *DealsDealIDGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *DealsDealIDGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *DealsGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *DealsGetOK) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s DealsGetOKType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *DealsGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *DealsPostInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *DealsPostTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *ElectronicCertificate) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     20,
			MinLengthSet:  true,
			MaxLength:     30,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.CertificateID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "certificate_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.AvailableCompensation.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "available_compensation",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.AppliedCompensation.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "applied_compensation",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateAppliedCompensation) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateApprovedPaymentArticle) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ArticleNumber.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.TruCode.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tru_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ArticleCode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_code",
			Error: err,
		})
	}
	if err := func() error {
		if s.Certificates == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Certificates {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "certificates",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateArticle) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ArticleNumber.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.TruCode.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tru_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ArticleCode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_code",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     128,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ArticleName)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Price.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "price",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ElectronicCertificateArticleCode) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     128,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s ElectronicCertificateArticleNumber) Validate() error {
	alias := (int32)(s)
	if err := (validate.Int{
		MinSet:        true,
		Min:           1,
		MaxSet:        true,
		Max:           999,
		MinExclusive:  false,
		MaxExclusive:  false,
		MultipleOfSet: false,
		MultipleOf:    0,
		Pattern:       nil,
	}).Validate(int64(alias)); err != nil {
		return errors.Wrap(err, "int")
	}
	return nil
}

func (s *ElectronicCertificateArticlePrice) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateAvailableCompensation) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificatePayment) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{24}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BasketID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "basket_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificatePaymentAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificatePaymentData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{24}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BasketID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "basket_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificatePaymentDataAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundArticle) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        true,
			Max:           999,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.ArticleNumber)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "article_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        true,
			Max:           999,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.PaymentArticleNumber)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_article_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.TruCode.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tru_code",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        false,
			Max:           0,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.Quantity)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "quantity",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundDataRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{24}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BasketID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "basket_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundDataRequestAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundDataResponse) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{24}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BasketID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "basket_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundDataResponseAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundMethod) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ElectronicCertificate.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "electronic_certificate",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Articles {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "articles",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ElectronicCertificateRefundMethodData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ElectronicCertificate.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "electronic_certificate",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Articles {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "articles",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ElectronicCertificateTruCode) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     30,
		MinLengthSet:  true,
		MaxLength:     30,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s FeeMoment) Validate() error {
	switch s {
	case "payment_succeeded":
		return nil
	case "deal_closed":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s FirstName) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     100,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["^[\\-a-zA-Zа-яёА-ЯЁ ]]*$"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *FiscalizationData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Provider.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "provider",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s FiscalizationProvider) Validate() error {
	switch s {
	case "atol":
		return nil
	case "avanpost":
		return nil
	case "a_qsi":
		return nil
	case "business_ru":
		return nil
	case "digital_kassa":
		return nil
	case "evotor":
		return nil
	case "first_ofd":
		return nil
	case "kit_invest":
		return nil
	case "komtet":
		return nil
	case "life_pay":
		return nil
	case "mertrade":
		return nil
	case "modul_kassa":
		return nil
	case "rocket":
		return nil
	case "shtrih_m":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Forbidden) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Type.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Code.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ForbiddenCode) Validate() error {
	switch s {
	case "forbidden":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ForbiddenType) Validate() error {
	switch s {
	case "error":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *IncomeReceipt) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ServiceName.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "service_name",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Amount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *IncomeReceiptAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s IncomeReceiptServiceName) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     50,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *IndustryDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["(^00[1-9]{1}$)|(^0[1-6]{1}[0-9]{1}$)|(^07[0-3]{1}$)"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.FederalID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "federal_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     32,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.DocumentNumber)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "document_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     256,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Value)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "value",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *InvalidCredentials) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Type.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Code.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s InvalidCredentialsCode) Validate() error {
	switch s {
	case "invalid_credentials":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s InvalidCredentialsType) Validate() error {
	switch s {
	case "error":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s InvoiceId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     39,
		MinLengthSet:  true,
		MaxLength:     39,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *InvoicingBankCardData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{6}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.First6)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first6",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Last4.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last4",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.ExpiryYear.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "expiry_year",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.CardType.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card_type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s Kbk) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     20,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["([\\d]{20})|(0)"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s LastName) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     200,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["^[\\-a-zA-Zа-яёА-ЯЁ ]]*$"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s Locale) Validate() error {
	switch s {
	case "ru_RU":
		return nil
	case "en_US":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *MarkCodeInfo) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Unknown.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     32,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "unknown",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Ean8.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     8,
					MinLengthSet:  true,
					MaxLength:     8,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "ean_8",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Ean13.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     13,
					MinLengthSet:  true,
					MaxLength:     13,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "ean_13",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Itf14.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     14,
					MinLengthSet:  true,
					MaxLength:     14,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "itf_14",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Gs10.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     38,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "gs_10",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Gs1m.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     200,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "gs_1m",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Short.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     38,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "short",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Fur.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     20,
					MinLengthSet:  true,
					MaxLength:     20,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "fur",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Egais20.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     33,
					MinLengthSet:  true,
					MaxLength:     33,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "egais_20",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Egais30.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     14,
					MinLengthSet:  true,
					MaxLength:     14,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "egais_30",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s MarkMode) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["^[0]{1}$"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *MarkQuantity) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        false,
			Max:           0,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.Numerator)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "numerator",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        false,
			Max:           0,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.Denominator)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "denominator",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *Me) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Fiscalization.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "fiscalization",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.PaymentMethods {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_methods",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Itn.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["\\d{1,20}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "itn",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.PayoutMethods {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payout_methods",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PayoutBalance.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payout_balance",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *MePayoutBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s MeStatus) Validate() error {
	switch s {
	case "enabled":
		return nil
	case "disabled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s Metadata) Validate() error {
	var failures []validate.FieldError

	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s MetadataInQueryParameter) Validate() error {
	var failures []validate.FieldError
	for key, elem := range s {
		if err := func() error {
			if err := (validate.String{
				MinLength:     0,
				MinLengthSet:  false,
				MaxLength:     512,
				MaxLengthSet:  true,
				Email:         false,
				Hostname:      false,
				Regex:         nil,
				MinNumeric:    0,
				MinNumericSet: false,
				MaxNumeric:    0,
				MaxNumericSet: false,
			}).Validate(string(elem)); err != nil {
				return errors.Wrap(err, "string")
			}
			return nil
		}(); err != nil {
			failures = append(failures, validate.FieldError{
				Name:  key,
				Error: err,
			})
		}
	}

	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s MiddleName) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     200,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["^[\\-a-zA-Zа-яёА-ЯЁ ]]*$"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *NotFound) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Type.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Code.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s NotFoundCode) Validate() error {
	switch s {
	case "not_found":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s NotFoundType) Validate() error {
	switch s {
	case "error":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s Oktmo) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     8,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["([\\d]{8})|(0)"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *Payment) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.IncomeAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "income_amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentMethod.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_method",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Confirmation.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "confirmation",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.RefundedAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "refunded_amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReceiptRegistration.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_registration",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CancellationDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "cancellation_details",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transfers {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "transfers",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MerchantCustomerID.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     200,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "merchant_customer_id",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.InvoiceDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "invoice_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentCancellationDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Party.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "party",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Reason.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "reason",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentCancellationDetailsParty) Validate() error {
	switch s {
	case "yoo_money":
		return nil
	case "payment_network":
		return nil
	case "merchant":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentCancellationDetailsReason) Validate() error {
	switch s {
	case "3d_secure_failed":
		return nil
	case "call_issuer":
		return nil
	case "card_expired":
		return nil
	case "payment_method_limit_exceeded":
		return nil
	case "payment_method_restricted":
		return nil
	case "country_forbidden":
		return nil
	case "general_decline":
		return nil
	case "fraud_suspected":
		return nil
	case "identification_required":
		return nil
	case "insufficient_funds":
		return nil
	case "invalid_card_number":
		return nil
	case "invalid_csc":
		return nil
	case "issuer_unavailable":
		return nil
	case "canceled_by_merchant":
		return nil
	case "permission_revoked":
		return nil
	case "internal_timeout":
		return nil
	case "expired_on_confirmation":
		return nil
	case "expired_on_capture":
		return nil
	case "unsupported_mobile_operator":
		return nil
	case "deal_expired":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentConfirmation) Validate() error {
	switch s.Type {
	case ConfirmationRedirectPaymentConfirmation:
		if err := s.ConfirmationRedirect.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationPaymentConfirmation:
		if err := s.Confirmation.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationQrPaymentConfirmation:
		if err := s.ConfirmationQr.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationEmbeddedPaymentConfirmation:
		if err := s.ConfirmationEmbedded.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationMobileApplicationPaymentConfirmation:
		if err := s.ConfirmationMobileApplication.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentDeal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Settlements.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "settlements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     36,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *PaymentIncomeAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentInvoiceDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.ID.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentList) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentListType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodAlfabank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodAlfabankStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodApplePay) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodApplePayStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodB2bSberbank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PaymentPurpose.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_purpose",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.VatData.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "vat_data",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PayerBankDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payer_bank_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodB2bSberbankStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentMethodB2bSberbankVatData) Validate() error {
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankCalculatedVatData.Validate(); err != nil {
			return err
		}
		return nil
	case B2bSberbankUntaxedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankUntaxedVatData.Validate(); err != nil {
			return err
		}
		return nil
	case B2bSberbankMixedVatDataPaymentMethodB2bSberbankVatData:
		if err := s.B2bSberbankMixedVatData.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentMethodBankCard) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodBankCardStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodCash) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodCashStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataB2bSberbank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PaymentPurpose.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_purpose",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.VatData.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "vat_data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataB2bSberbankType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentMethodDataB2bSberbankVatData) Validate() error {
	switch s.Type {
	case B2bSberbankCalculatedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankCalculatedVatData.Validate(); err != nil {
			return err
		}
		return nil
	case B2bSberbankUntaxedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankUntaxedVatData.Validate(); err != nil {
			return err
		}
		return nil
	case B2bSberbankMixedVatDataPaymentMethodDataB2bSberbankVatData:
		if err := s.B2bSberbankMixedVatData.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentMethodDataBankCard) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataBankCardType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataCash) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataCashType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataElectronicCertificate) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ElectronicCertificate.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "electronic_certificate",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Articles {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "articles",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataElectronicCertificateType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataMobileBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{4,15}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Phone)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataMobileBalanceType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataSberBnpl) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataSberBnplType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataSberLoan) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataSberLoanType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataSberbank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataSberbankType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataSbp) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataSbpType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataTinkoffBank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataTinkoffBankType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodDataYooMoney) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodDataYooMoneyType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "yoo_money":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodElectronicCertificate) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ElectronicCertificate.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "electronic_certificate",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Articles {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "articles",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentMethodElectronicCertificateCard) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.First6.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first6",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Last4.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last4",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.ExpiryYear.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "expiry_year",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.CardType.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Source.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "source",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodElectronicCertificateStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodGooglePay) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodGooglePayStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodInstallments) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodInstallmentsStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodMobileBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodMobileBalanceStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodQiwi) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodQiwiStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodSberBnpl) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodSberBnplStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodSberLoan) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LoanOption.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "loan_option",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.DiscountAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "discount_amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentMethodSberLoanDiscountAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodSberLoanStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodSberbank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodSberbankStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodSbp) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PayerBankDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payer_bank_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodSbpStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentMethodStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodTinkoffBank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodTinkoffBankStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentMethodType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "cash":
		return nil
	case "alfabank":
		return nil
	case "webmoney":
		return nil
	case "wechat":
		return nil
	case "apple_pay":
		return nil
	case "google_pay":
		return nil
	case "qiwi":
		return nil
	case "installments":
		return nil
	case "yoo_money":
		return nil
	case "sberbank":
		return nil
	case "mobile_balance":
		return nil
	case "b2b_sberbank":
		return nil
	case "tinkoff_bank":
		return nil
	case "sbp":
		return nil
	case "sber_loan":
		return nil
	case "electronic_certificate":
		return nil
	case "sber_bnpl":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodWeChat) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodWeChatStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodWebmoney) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodWebmoneyStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodYooMoney) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AccountNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{11,33}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodYooMoneyStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "active":
		return nil
	case "inactive":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodsConfirmationDataRedirect) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     2048,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ReturnURL)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Locale.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "locale",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentMethodsConfirmationRedirect) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReturnURL.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     2048,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "return_url",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentMethodsConfirmationType) Validate() error {
	switch s {
	case "redirect":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentMethodsPaymentMethodIDGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s PaymentMethodsPaymentMethodIDGetOK) Validate() error {
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPaymentMethodIDGetOK:
		if err := s.SavePaymentMethodBankCard.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentMethodsPaymentMethodIDGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PaymentMethodsPostInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s PaymentMethodsPostOK) Validate() error {
	switch s.Type {
	case SavePaymentMethodBankCardPaymentMethodsPostOK:
		if err := s.SavePaymentMethodBankCard.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s PaymentMethodsPostReq) Validate() error {
	switch s.Type {
	case SavePaymentMethodDataBankCardPaymentMethodsPostReq:
		if err := s.SavePaymentMethodDataBankCard.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentMethodsPostTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PaymentOrderDataUtilities) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["(?s).{1,210}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.PaymentPurpose)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_purpose",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Recipient.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "recipient",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Kbk.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "kbk",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Oktmo.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "oktmo",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentPeriod.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_period",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentDocumentID.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     18,
					MinLengthSet:  true,
					MaxLength:     18,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_document_id",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentDocumentNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     30,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["(.)([0-9а-яА-Яa-zA-Z]+)(.)"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_document_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AccountNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     30,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["(.)([0-9а-яА-Яa-zA-Z]+)(.)"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.UnifiedAccountNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     10,
					MinLengthSet:  true,
					MaxLength:     10,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "unified_account_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ServiceID.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     13,
					MinLengthSet:  true,
					MaxLength:     13,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "service_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentOrderDataUtilitiesAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentOrderDataUtilitiesRecipient) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{10}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Inn)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "inn",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{9}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Kpp)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "kpp",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Bank.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentOrderDataUtilitiesRecipientBank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     45,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Name)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "name",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{9}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Bic)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bic",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentOrderDataUtilitiesType) Validate() error {
	switch s {
	case "utilities":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentOverviewStatementData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.DeliveryMethod.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "delivery_method",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentOverviewStatementDataType) Validate() error {
	switch s {
	case "payment_overview":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PaymentOverviewStatementDeliveryMethodType) Validate() error {
	switch s {
	case "email":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentOverviewStatementEmailDeliveryMethod) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     254,
			MaxLengthSet:  true,
			Email:         true,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Email)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "email",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentPaymentMethod) Validate() error {
	switch s.Type {
	case PaymentMethodBankCardPaymentPaymentMethod:
		if err := s.PaymentMethodBankCard.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodCashPaymentPaymentMethod:
		if err := s.PaymentMethodCash.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodQiwiPaymentPaymentMethod:
		if err := s.PaymentMethodQiwi.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodAlfabankPaymentPaymentMethod:
		if err := s.PaymentMethodAlfabank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodWebmoneyPaymentPaymentMethod:
		if err := s.PaymentMethodWebmoney.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodSberbankPaymentPaymentMethod:
		if err := s.PaymentMethodSberbank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodTinkoffBankPaymentPaymentMethod:
		if err := s.PaymentMethodTinkoffBank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodYooMoneyPaymentPaymentMethod:
		if err := s.PaymentMethodYooMoney.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodApplePayPaymentPaymentMethod:
		if err := s.PaymentMethodApplePay.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodGooglePayPaymentPaymentMethod:
		if err := s.PaymentMethodGooglePay.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodMobileBalancePaymentPaymentMethod:
		if err := s.PaymentMethodMobileBalance.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodInstallmentsPaymentPaymentMethod:
		if err := s.PaymentMethodInstallments.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodB2bSberbankPaymentPaymentMethod:
		if err := s.PaymentMethodB2bSberbank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodWeChatPaymentPaymentMethod:
		if err := s.PaymentMethodWeChat.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodSbpPaymentPaymentMethod:
		if err := s.PaymentMethodSbp.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodSberLoanPaymentPaymentMethod:
		if err := s.PaymentMethodSberLoan.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodElectronicCertificatePaymentPaymentMethod:
		if err := s.PaymentMethodElectronicCertificate.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodSberBnplPaymentPaymentMethod:
		if err := s.PaymentMethodSberBnpl.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentPeriod) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        true,
			Max:           12,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.Month)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "month",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1920,
			MaxSet:        true,
			Max:           2050,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.Year)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "year",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentPurpose) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     0,
		MaxLengthSet:  false,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["(?s).{1,210}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s PaymentReceiptRegistration) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentRefundedAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "waiting_for_capture":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PaymentsPaymentIDCapturePostReq) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Amount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Receipt.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Airline.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "airline",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transfers {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "transfers",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPaymentIDCapturePostReqAirline) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.TicketNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     150,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{1,150}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "ticket_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.BookingReference.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     20,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "booking_reference",
			Error: err,
		})
	}
	if err := func() error {
		if s.Passengers == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    0,
			MinLengthSet: true,
			MaxLength:    500,
			MaxLengthSet: true,
		}).ValidateLength(len(s.Passengers)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Passengers {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "passengers",
			Error: err,
		})
	}
	if err := func() error {
		if s.Legs == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    0,
			MinLengthSet: true,
			MaxLength:    4,
			MaxLengthSet: true,
		}).ValidateLength(len(s.Legs)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Legs {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "legs",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPaymentIDCapturePostReqAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPaymentIDCapturePostReqDeal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Settlements.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "settlements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPostReq) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Receipt.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentMethodData.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_method_data",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Confirmation.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "confirmation",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Airline.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "airline",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transfers {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "transfers",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MerchantCustomerID.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     200,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "merchant_customer_id",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentOrder.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_order",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Receiver.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receiver",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Statements {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "statements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPostReqAirline) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.TicketNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     150,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{1,150}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "ticket_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.BookingReference.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     20,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "booking_reference",
			Error: err,
		})
	}
	if err := func() error {
		if s.Passengers == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    0,
			MinLengthSet: true,
			MaxLength:    500,
			MaxLengthSet: true,
		}).ValidateLength(len(s.Passengers)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Passengers {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "passengers",
			Error: err,
		})
	}
	if err := func() error {
		if s.Legs == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    0,
			MinLengthSet: true,
			MaxLength:    4,
			MaxLengthSet: true,
		}).ValidateLength(len(s.Legs)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Legs {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "legs",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PaymentsPostReqAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentsPostReqConfirmation) Validate() error {
	switch s.Type {
	case ConfirmationDataRedirectPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataRedirect.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationDataExternalPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataExternal.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationDataQrPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataQr.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationDataEmbeddedPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataEmbedded.Validate(); err != nil {
			return err
		}
		return nil
	case ConfirmationDataMobileApplicationPaymentsPostReqConfirmation:
		if err := s.ConfirmationDataMobileApplication.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PaymentsPostReqDeal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Settlements.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "settlements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PaymentsPostReqPaymentMethodData) Validate() error {
	switch s.Type {
	case PaymentMethodDataBankCardPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataBankCard.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataCashPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataCash.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataSberbankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberbank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataTinkoffBankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataTinkoffBank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataYooMoneyPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataYooMoney.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataMobileBalancePaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataMobileBalance.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataB2bSberbankPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataB2bSberbank.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataSbpPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSbp.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataSberLoanPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberLoan.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataElectronicCertificatePaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataElectronicCertificate.Validate(); err != nil {
			return err
		}
		return nil
	case PaymentMethodDataSberBnplPaymentsPostReqPaymentMethodData:
		if err := s.PaymentMethodDataSberBnpl.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s PaymentsPostReqPaymentOrder) Validate() error {
	switch s.Type {
	case PaymentOrderDataUtilitiesPaymentsPostReqPaymentOrder:
		if err := s.PaymentOrderDataUtilities.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s PaymentsPostReqReceiver) Validate() error {
	switch s.Type {
	case ReceiverMobileBalancePaymentsPostReqReceiver:
		if err := s.ReceiverMobileBalance.Validate(); err != nil {
			return err
		}
		return nil
	case ReceiverDigitalWalletPaymentsPostReqReceiver:
		if err := s.ReceiverDigitalWallet.Validate(); err != nil {
			return err
		}
		return nil
	case ReceiverBankAccountPaymentsPostReqReceiver:
		if err := s.ReceiverBankAccount.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s PaymentsPostReqStatementsItem) Validate() error {
	switch s.Type {
	case PaymentOverviewStatementDataPaymentsPostReqStatementsItem:
		if err := s.PaymentOverviewStatementData.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *Payout) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PayoutDestination.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payout_destination",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.SelfEmployed.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "self_employed",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Receipt.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CancellationDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "cancellation_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutCancellationDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Party.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "party",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Reason.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "reason",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PayoutCancellationDetailsParty) Validate() error {
	switch s {
	case "yoo_money":
		return nil
	case "payout_network":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PayoutCancellationDetailsReason) Validate() error {
	switch s {
	case "insufficient_funds":
		return nil
	case "fraud_suspected":
		return nil
	case "one_time_limit_exceeded":
		return nil
	case "periodic_limit_exceeded":
		return nil
	case "rejected_by_payee":
		return nil
	case "general_decline":
		return nil
	case "issuer_unavailable":
		return nil
	case "recipient_not_found":
		return nil
	case "recipient_check_failed":
		return nil
	case "identification_required":
		return nil
	case "self_employed_annual_limit_exceeded":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PayoutCardData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{6}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.First6)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first6",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Last4.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last4",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.CardType.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card_type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutDeal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutDealInfo) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PayoutDestinationDataType) Validate() error {
	switch s {
	case "yoo_money":
		return nil
	case "bank_card":
		return nil
	case "sbp":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PayoutDestinationType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "yoo_money":
		return nil
	case "sbp":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PayoutId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     50,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s PayoutMethodType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	case "yoo_money":
		return nil
	case "sbp":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PayoutPayoutDestination) Validate() error {
	switch s.Type {
	case PayoutToCardDestinationPayoutPayoutDestination:
		if err := s.PayoutToCardDestination.Validate(); err != nil {
			return err
		}
		return nil
	case PayoutToYooMoneyDestinationPayoutPayoutDestination:
		if err := s.PayoutToYooMoneyDestination.Validate(); err != nil {
			return err
		}
		return nil
	case PayoutToSbpDestinationPayoutPayoutDestination:
		if err := s.PayoutToSbpDestination.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PayoutRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PayoutDestinationData.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payout_destination_data",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if s.PersonalData == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    1,
			MinLengthSet: true,
			MaxLength:    2,
			MaxLengthSet: true,
		}).ValidateLength(len(s.PersonalData)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.PersonalData {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "personal_data",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutRequestAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PayoutRequestPayoutDestinationData) Validate() error {
	switch s.Type {
	case PayoutToYooMoneyDestinationDataPayoutRequestPayoutDestinationData:
		if err := s.PayoutToYooMoneyDestinationData.Validate(); err != nil {
			return err
		}
		return nil
	case PayoutToBankCardDestinationDataPayoutRequestPayoutDestinationData:
		if err := s.PayoutToBankCardDestinationData.Validate(); err != nil {
			return err
		}
		return nil
	case PayoutToSbpDestinationDataPayoutRequestPayoutDestinationData:
		if err := s.PayoutToSbpDestinationData.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PayoutSelfEmployed) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutStatementRecipientPersonalDataRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.LastName.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.FirstName.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first_name",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MiddleName.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "middle_name",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PayoutStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PayoutToBankCardDestinationData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Card.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutToCardDestination) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutToSbpDestination) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{4,15}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Phone)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     12,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BankID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutToSbpDestinationData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{4,15}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Phone)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     12,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[a-zA-Z0-9]{12}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.BankID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutToYooMoneyDestination) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.AccountNumber.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutToYooMoneyDestinationData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     11,
			MinLengthSet:  true,
			MaxLength:     33,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.AccountNumber)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutsGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsList) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PayoutsListType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *PayoutsPayoutIDGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsPayoutIDGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsPersonalData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PayoutsPostInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsPostTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsSearchGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PayoutsSearchGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PersonalData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CancellationDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "cancellation_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PersonalDataCancellationDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Party.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "party",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Reason.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "reason",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s PersonalDataCancellationDetailsParty) Validate() error {
	switch s {
	case "yoo_money":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PersonalDataCancellationDetailsReason) Validate() error {
	switch s {
	case "expired_by_timeout":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PersonalDataId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     50,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *PersonalDataPersonalDataIDGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PersonalDataPersonalDataIDGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *PersonalDataPostInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s PersonalDataPostReq) Validate() error {
	switch s.Type {
	case SbpPayoutRecipientPersonalDataRequestPersonalDataPostReq:
		if err := s.SbpPayoutRecipientPersonalDataRequest.Validate(); err != nil {
			return err
		}
		return nil
	case PayoutStatementRecipientPersonalDataRequestPersonalDataPostReq:
		if err := s.PayoutStatementRecipientPersonalDataRequest.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *PersonalDataPostTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s PersonalDataStatus) Validate() error {
	switch s {
	case "waiting_for_operation":
		return nil
	case "active":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s PersonalDataType) Validate() error {
	switch s {
	case "payout_statement_recipient":
		return nil
	case "sbp_payout_recipient":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Receipt) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if err := func() error {
		if s.Settlements == nil {
			return nil // optional
		}
		if err := (validate.Array{
			MinLength:    1,
			MinLengthSet: true,
			MaxLength:    0,
			MaxLengthSet: false,
		}).ValidateLength(len(s.Settlements)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Settlements {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "settlements",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.TaxSystemCode.Get(); ok {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           6,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tax_system_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Timezone.Get(); ok {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           11,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "timezone",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.ReceiptIndustryDetails {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_industry_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReceiptOperationalDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_operational_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiptData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Customer.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "customer",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.TaxSystemCode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tax_system_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Timezone.Get(); ok {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           11,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
					Pattern:       nil,
				}).Validate(int64(value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "timezone",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.ReceiptIndustryDetails {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_industry_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReceiptOperationalDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_operational_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiptDataCustomer) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Inn.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["\\d{10}|\\d{12}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "inn",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Email.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     254,
					MaxLengthSet:  true,
					Email:         true,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "email",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiptDataItem) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.VatCode.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "vat_code",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Quantity.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "quantity",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Measure.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "measure",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkQuantity.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_quantity",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentSubject.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_subject",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentMode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_mode",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CustomsDeclarationNumber.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "customs_declaration_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlannedStatus.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "planned_status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkCodeInfo.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_code_info",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkMode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_mode",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PaymentSubjectIndustryDetails.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_subject_industry_details",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiptDataItemAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiptDataReceiptOperationalDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           0,
			MaxSet:        true,
			Max:           255,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.OperationID)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "operation_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     64,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Value)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "value",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     39,
		MinLengthSet:  true,
		MaxLength:     39,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *ReceiptItem) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.Quantity)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "quantity",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           1,
			MaxSet:        true,
			Max:           12,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.VatCode)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "vat_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentSubject.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_subject",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PaymentMode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_mode",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CustomsDeclarationNumber.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     1,
					MinLengthSet:  true,
					MaxLength:     32,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "customs_declaration_number",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Supplier.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "supplier",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AgentType.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "agent_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkCodeInfo.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_code_info",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Measure.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "measure",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.PaymentSubjectIndustryDetails {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_subject_industry_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlannedStatus.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "planned_status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkMode.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_mode",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MarkQuantity.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "mark_quantity",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptItemAgentType) Validate() error {
	switch s {
	case "banking_payment_agent":
		return nil
	case "banking_payment_subagent":
		return nil
	case "payment_agent":
		return nil
	case "payment_subagent":
		return nil
	case "attorney":
		return nil
	case "commissioner":
		return nil
	case "agent":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *ReceiptItemAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptItemCustomsDeclarationNumber) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     1,
		MinLengthSet:  true,
		MaxLength:     32,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s ReceiptItemMeasure) Validate() error {
	switch s {
	case "piece":
		return nil
	case "gram":
		return nil
	case "kilogram":
		return nil
	case "ton":
		return nil
	case "centimeter":
		return nil
	case "decimeter":
		return nil
	case "meter":
		return nil
	case "square_centimeter":
		return nil
	case "square_decimeter":
		return nil
	case "square_meter":
		return nil
	case "milliliter":
		return nil
	case "liter":
		return nil
	case "cubic_meter":
		return nil
	case "kilowatt_hour":
		return nil
	case "gigacalorie":
		return nil
	case "day":
		return nil
	case "hour":
		return nil
	case "minute":
		return nil
	case "second":
		return nil
	case "kilobyte":
		return nil
	case "megabyte":
		return nil
	case "gigabyte":
		return nil
	case "terabyte":
		return nil
	case "another":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ReceiptItemPaymentMode) Validate() error {
	switch s {
	case "full_prepayment":
		return nil
	case "partial_prepayment":
		return nil
	case "advance":
		return nil
	case "full_payment":
		return nil
	case "partial_payment":
		return nil
	case "credit":
		return nil
	case "credit_payment":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ReceiptItemPaymentSubject) Validate() error {
	switch s {
	case "commodity":
		return nil
	case "excise":
		return nil
	case "job":
		return nil
	case "service":
		return nil
	case "gambling_bet":
		return nil
	case "gambling_prize":
		return nil
	case "lottery":
		return nil
	case "lottery_prize":
		return nil
	case "intellectual_activity":
		return nil
	case "payment":
		return nil
	case "agent_commission":
		return nil
	case "property_right":
		return nil
	case "non_operating_gain":
		return nil
	case "insurance_premium":
		return nil
	case "sales_tax":
		return nil
	case "resort_fee":
		return nil
	case "composite":
		return nil
	case "another":
		return nil
	case "fine":
		return nil
	case "tax":
		return nil
	case "lien":
		return nil
	case "cost":
		return nil
	case "pension_insurance_without_payouts":
		return nil
	case "pension_insurance_with_payouts":
		return nil
	case "health_insurance_without_payouts":
		return nil
	case "health_insurance_with_payouts":
		return nil
	case "health_insurance":
		return nil
	case "casino":
		return nil
	case "agent_withdrawals":
		return nil
	case "non_marked_excise":
		return nil
	case "marked_excise":
		return nil
	case "marked":
		return nil
	case "non_marked":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ReceiptItemPaymentSubjectIndustryDetails) Validate() error {
	alias := ([]IndustryDetails)(s)
	var failures []validate.FieldError
	for i, elem := range alias {
		if err := func() error {
			if err := elem.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			failures = append(failures, validate.FieldError{
				Name:  fmt.Sprintf("[%d]", i),
				Error: err,
			})
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptItemPlannedStatus) Validate() error {
	alias := (int32)(s)
	if err := (validate.Int{
		MinSet:        true,
		Min:           1,
		MaxSet:        true,
		Max:           6,
		MinExclusive:  false,
		MaxExclusive:  false,
		MultipleOfSet: false,
		MultipleOf:    0,
		Pattern:       nil,
	}).Validate(int64(alias)); err != nil {
		return errors.Wrap(err, "int")
	}
	return nil
}

func (s ReceiptItemQuantity) Validate() error {
	alias := (float64)(s)
	if err := (validate.Float{}).Validate(float64(alias)); err != nil {
		return errors.Wrap(err, "float")
	}
	return nil
}

func (s *ReceiptItemSupplierWithInn) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Phone.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["[0-9]{4,15}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Inn.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     0,
					MaxLengthSet:  false,
					Email:         false,
					Hostname:      false,
					Regex:         regexMap["\\d{10}|\\d{12}"],
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "inn",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptItemVatCode) Validate() error {
	alias := (int32)(s)
	if err := (validate.Int{
		MinSet:        true,
		Min:           1,
		MaxSet:        true,
		Max:           12,
		MinExclusive:  false,
		MaxExclusive:  false,
		MultipleOfSet: false,
		MultipleOf:    0,
		Pattern:       nil,
	}).Validate(int64(alias)); err != nil {
		return errors.Wrap(err, "int")
	}
	return nil
}

func (s *ReceiptReceiptOperationalDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Int{
			MinSet:        true,
			Min:           0,
			MaxSet:        true,
			Max:           255,
			MinExclusive:  false,
			MaxExclusive:  false,
			MultipleOfSet: false,
			MultipleOf:    0,
			Pattern:       nil,
		}).Validate(int64(s.OperationID)); err != nil {
			return errors.Wrap(err, "int")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "operation_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     64,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Value)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "value",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptRegistrationStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ReceiptStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ReceiptType) Validate() error {
	switch s {
	case "payment":
		return nil
	case "refund":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *ReceiptsGetOK) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiptsGetOKType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *ReceiverBankAccount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     20,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{20}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.AccountNumber)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     9,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{9}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Bic)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bic",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiverDigitalWallet) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     20,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.AccountNumber)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "account_number",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ReceiverMobileBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     0,
			MaxLengthSet:  false,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["[0-9]{4,15}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Phone)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "phone",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ReceiverType) Validate() error {
	switch s {
	case "mobile_balance":
		return nil
	case "digital_wallet":
		return nil
	case "bank_account":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Refund) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PaymentID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CancellationDetails.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "cancellation_details",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.ReceiptRegistration.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt_registration",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     250,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Sources {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "sources",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.RefundMethod.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "refund_method",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundCancellationDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Party.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "party",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Reason.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "reason",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s RefundCancellationDetailsParty) Validate() error {
	switch s {
	case "yoo_money":
		return nil
	case "refund_network":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s RefundCancellationDetailsReason) Validate() error {
	switch s {
	case "yoo_money_account_closed":
		return nil
	case "insufficient_funds":
		return nil
	case "general_decline":
		return nil
	case "rejected_by_payee":
		return nil
	case "rejected_by_timeout":
		return nil
	case "payment_basket_id_not_found":
		return nil
	case "payment_article_number_not_found":
		return nil
	case "payment_tru_code_not_found":
		return nil
	case "too_many_refunding_articles":
		return nil
	case "some_articles_already_refunded":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RefundDealData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.RefundSettlements.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "refund_settlements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundDealInfo) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:     36,
			MinLengthSet:  true,
			MaxLength:     50,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.ID)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.RefundSettlements.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "refund_settlements",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s RefundId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     36,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *RefundList) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s RefundListType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s RefundMethodType) Validate() error {
	switch s {
	case "sbp":
		return nil
	case "electronic_certificate":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s RefundReceiptRegistration) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s RefundRefundMethod) Validate() error {
	switch s.Type {
	case SbpRefundMethodRefundRefundMethod:
		if err := s.SbpRefundMethod.Validate(); err != nil {
			return err
		}
		return nil
	case ElectronicCertificateRefundMethodRefundRefundMethod:
		if err := s.ElectronicCertificateRefundMethod.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *RefundSourcesData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlatformFeeAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "platform_fee_amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundSourcesDataAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundSourcesDataPlatformFeeAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s RefundStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RefundsPostReq) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.PaymentID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payment_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     250,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Receipt.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "receipt",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Sources {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "sources",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Deal.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "deal",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.RefundMethodData.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "refund_method_data",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RefundsPostReqAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s RefundsPostReqRefundMethodData) Validate() error {
	switch s.Type {
	case ElectronicCertificateRefundMethodDataRefundsPostReqRefundMethodData:
		if err := s.ElectronicCertificateRefundMethodData.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s ReturnUrl) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     2048,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *SafeDeal) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.ID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "id",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.FeeMoment.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "fee_moment",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Balance.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "balance",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.PayoutBalance.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "payout_balance",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SafeDealBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SafeDealPayoutBalance) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SafeDealRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.FeeMoment.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "fee_moment",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SavePaymentMethodBankCard) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Confirmation.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "confirmation",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SavePaymentMethodBankCardConfirmation) Validate() error {
	switch s.Type {
	case PaymentMethodsConfirmationRedirectSavePaymentMethodBankCardConfirmation:
		if err := s.PaymentMethodsConfirmationRedirect.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *SavePaymentMethodDataBankCard) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Confirmation.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "confirmation",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Card.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "card",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SavePaymentMethodDataBankCardType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s SavePaymentMethodType) Validate() error {
	switch s {
	case "bank_card":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s SbpBankBic) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     9,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["\\d{9}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s SbpBankId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     0,
		MinLengthSet:  false,
		MaxLength:     12,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         regexMap["[a-zA-Z0-9]{12}"],
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *SbpBanksGetInternalServerError) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *SbpBanksGetOK) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SbpBanksGetOKType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *SbpBanksGetTooManyRequests) Validate() error {
	alias := (*TooManyRequests)(s)
	if err := alias.Validate(); err != nil {
		return err
	}
	return nil
}

func (s *SbpParticipantBank) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.BankID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     128,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         nil,
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Name)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "name",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Bic.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bic",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SbpPayerBankDetails) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.BankID.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bank_id",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.String{
			MinLength:     0,
			MinLengthSet:  false,
			MaxLength:     9,
			MaxLengthSet:  true,
			Email:         false,
			Hostname:      false,
			Regex:         regexMap["\\d{9}"],
			MinNumeric:    0,
			MinNumericSet: false,
			MaxNumeric:    0,
			MaxNumericSet: false,
		}).Validate(string(s.Bic)); err != nil {
			return errors.Wrap(err, "string")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "bic",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SbpPayoutRecipientPersonalDataRequest) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.LastName.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "last_name",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.FirstName.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "first_name",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.MiddleName.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "middle_name",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SbpRefundMethod) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SelfEmployedId) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     36,
		MinLengthSet:  true,
		MaxLength:     50,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}

func (s *Settlement) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SettlementAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SettlementItemType) Validate() error {
	switch s {
	case "payout":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s SettlementPaymentArray) Validate() error {
	alias := ([]SettlementPaymentArrayItem)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	var failures []validate.FieldError
	for i, elem := range alias {
		if err := func() error {
			if err := elem.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			failures = append(failures, validate.FieldError{
				Name:  fmt.Sprintf("[%d]", i),
				Error: err,
			})
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SettlementPaymentArrayItem) Validate() error {
	switch s.Type {
	case SettlementPayoutPaymentSettlementPaymentArrayItem:
		if err := s.SettlementPayoutPayment.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *SettlementPayoutPayment) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SettlementPayoutPaymentAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SettlementPayoutRefund) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *SettlementPayoutRefundAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SettlementRefundArray) Validate() error {
	alias := ([]SettlementRefundArrayItem)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	var failures []validate.FieldError
	for i, elem := range alias {
		if err := func() error {
			if err := elem.Validate(); err != nil {
				return err
			}
			return nil
		}(); err != nil {
			failures = append(failures, validate.FieldError{
				Name:  fmt.Sprintf("[%d]", i),
				Error: err,
			})
		}
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s SettlementRefundArrayItem) Validate() error {
	switch s.Type {
	case SettlementPayoutRefundSettlementRefundArrayItem:
		if err := s.SettlementPayoutRefund.Validate(); err != nil {
			return err
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s SettlementType) Validate() error {
	switch s {
	case "cashless":
		return nil
	case "prepayment":
		return nil
	case "postpayment":
		return nil
	case "consideration":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s TaxSystemCode) Validate() error {
	alias := (int32)(s)
	if err := (validate.Int{
		MinSet:        true,
		Min:           1,
		MaxSet:        true,
		Max:           6,
		MinExclusive:  false,
		MaxExclusive:  false,
		MultipleOfSet: false,
		MultipleOf:    0,
		Pattern:       nil,
	}).Validate(int64(alias)); err != nil {
		return errors.Wrap(err, "int")
	}
	return nil
}

func (s *TooManyRequests) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Type.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Code.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "code",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s TooManyRequestsCode) Validate() error {
	switch s {
	case "too_many_requests":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s TooManyRequestsType) Validate() error {
	switch s {
	case "error":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Transfer) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Status.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "status",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlatformFeeAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "platform_fee_amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferData) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlatformFeeAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "platform_fee_amount",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferDataAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferDataPayment) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Amount.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.PlatformFeeAmount.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "platform_fee_amount",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Description.Get(); ok {
			if err := func() error {
				if err := (validate.String{
					MinLength:     0,
					MinLengthSet:  false,
					MaxLength:     128,
					MaxLengthSet:  true,
					Email:         false,
					Hostname:      false,
					Regex:         nil,
					MinNumeric:    0,
					MinNumericSet: false,
					MaxNumeric:    0,
					MaxNumericSet: false,
				}).Validate(string(value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "description",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Metadata.Get(); ok {
			if err := func() error {
				if err := value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "metadata",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferDataPaymentAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferDataPaymentPlatformFeeAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferDataPlatformFeeAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransferPlatformFeeAmount) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Currency.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "currency",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s TransferStatus) Validate() error {
	switch s {
	case "pending":
		return nil
	case "waiting_for_capture":
		return nil
	case "succeeded":
		return nil
	case "canceled":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Webhook) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Event.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "event",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s WebhookEvent) Validate() error {
	switch s {
	case "payment.waiting_for_capture":
		return nil
	case "payment.succeeded":
		return nil
	case "payment.canceled":
		return nil
	case "refund.succeeded":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *WebhookList) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Type.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "type",
			Error: err,
		})
	}
	if err := func() error {
		if s.Items == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Items {
			if err := func() error {
				if err := elem.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				failures = append(failures, validate.FieldError{
					Name:  fmt.Sprintf("[%d]", i),
					Error: err,
				})
			}
		}
		if len(failures) > 0 {
			return &validate.Error{Fields: failures}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "items",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s WebhookListType) Validate() error {
	switch s {
	case "list":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *WebhooksPostReq) Validate() error {
	if s == nil {
		return validate.ErrNilPointer
	}

	var failures []validate.FieldError
	if err := func() error {
		if err := s.Event.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "event",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s WebhooksPostReqEvent) Validate() error {
	switch s {
	case "payment.waiting_for_capture":
		return nil
	case "payment.succeeded":
		return nil
	case "payment.canceled":
		return nil
	case "refund.succeeded":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s YooMoneyAccountNumber) Validate() error {
	alias := (string)(s)
	if err := (validate.String{
		MinLength:     11,
		MinLengthSet:  true,
		MaxLength:     33,
		MaxLengthSet:  true,
		Email:         false,
		Hostname:      false,
		Regex:         nil,
		MinNumeric:    0,
		MinNumericSet: false,
		MaxNumeric:    0,
		MaxNumericSet: false,
	}).Validate(string(alias)); err != nil {
		return errors.Wrap(err, "string")
	}
	return nil
}