oas_validators_gen.go

// Code generated by ogen, DO NOT EDIT.

package firefly

import (
	"fmt"

	"github.com/go-faster/errors"

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

func (s *Account) Validate() error {
	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.AccountRole.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:  "account_role",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CreditCardType.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:  "credit_card_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LiabilityType.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:  "liability_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LiabilityDirection.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:  "liability_direction",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.InterestPeriod.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:  "interest_period",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *AccountArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s AccountRoleProperty) Validate() error {
	switch s {
	case "defaultAsset":
		return nil
	case "sharedAsset":
		return nil
	case "savingAsset":
		return nil
	case "ccAsset":
		return nil
	case "cashWalletAsset":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s AccountSearchFieldFilter) Validate() error {
	switch s {
	case "all":
		return nil
	case "iban":
		return nil
	case "name":
		return nil
	case "number":
		return nil
	case "id":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

func (s *AccountStore) Validate() error {
	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.AccountRole.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:  "account_role",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CreditCardType.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:  "credit_card_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LiabilityType.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:  "liability_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LiabilityDirection.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:  "liability_direction",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.InterestPeriod.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:  "interest_period",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s AccountTypeFilter) Validate() error {
	switch s {
	case "all":
		return nil
	case "asset":
		return nil
	case "cash":
		return nil
	case "expense":
		return nil
	case "revenue":
		return nil
	case "special":
		return nil
	case "hidden":
		return nil
	case "liability":
		return nil
	case "liabilities":
		return nil
	case "Default account":
		return nil
	case "Cash account":
		return nil
	case "Asset account":
		return nil
	case "Expense account":
		return nil
	case "Revenue account":
		return nil
	case "Initial balance account":
		return nil
	case "Beneficiary account":
		return nil
	case "Import account":
		return nil
	case "Reconciliation account":
		return nil
	case "Loan":
		return nil
	case "Debt":
		return nil
	case "Mortgage":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s AccountTypeProperty) Validate() error {
	switch s {
	case "Default account":
		return nil
	case "Cash account":
		return nil
	case "Asset account":
		return nil
	case "Expense account":
		return nil
	case "Revenue account":
		return nil
	case "Initial balance account":
		return nil
	case "Beneficiary account":
		return nil
	case "Import account":
		return nil
	case "Reconciliation account":
		return nil
	case "Loan":
		return nil
	case "Debt":
		return nil
	case "Mortgage":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *AccountUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.AccountRole.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:  "account_role",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.CreditCardType.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:  "credit_card_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.LiabilityType.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:  "liability_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.InterestPeriod.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:  "interest_period",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s AttachableType) Validate() error {
	switch s {
	case "Account":
		return nil
	case "Budget":
		return nil
	case "Bill":
		return nil
	case "TransactionJournal":
		return nil
	case "PiggyBank":
		return nil
	case "Tag":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

func (s *AttachmentArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

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

func (s AutoBudgetPeriod) Validate() error {
	switch s {
	case "daily":
		return nil
	case "weekly":
		return nil
	case "monthly":
		return nil
	case "quarterly":
		return nil
	case "half-year":
		return nil
	case "yearly":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

func (s AutocompleteAccountArray) Validate() error {
	alias := ([]AutocompleteAccount)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteBillArray) Validate() error {
	alias := ([]AutocompleteBill)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteBudgetArray) Validate() error {
	alias := ([]AutocompleteBudget)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteCategoryArray) Validate() error {
	alias := ([]AutocompleteCategory)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteCurrencyArray) Validate() error {
	alias := ([]AutocompleteCurrency)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteCurrencyCodeArray) Validate() error {
	alias := ([]AutocompleteCurrencyCode)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteObjectGroupArray) Validate() error {
	alias := ([]AutocompleteObjectGroup)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompletePiggyArray) Validate() error {
	alias := ([]AutocompletePiggy)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompletePiggyBalanceArray) Validate() error {
	alias := ([]AutocompletePiggyBalance)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteRecurrenceArray) Validate() error {
	alias := ([]AutocompleteRecurrence)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteRuleArray) Validate() error {
	alias := ([]AutocompleteRule)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteRuleGroupArray) Validate() error {
	alias := ([]AutocompleteRuleGroup)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteTagArray) Validate() error {
	alias := ([]AutocompleteTag)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteTransactionArray) Validate() error {
	alias := ([]AutocompleteTransaction)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteTransactionIDArray) Validate() error {
	alias := ([]AutocompleteTransactionID)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s AutocompleteTransactionTypeArray) Validate() error {
	alias := ([]AutocompleteTransactionType)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s *AvailableBudgetArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s BasicSummary) Validate() error {
	var failures []validate.FieldError
	for key, elem := range s {
		if err := func() error {
			if err := elem.Validate(); err != nil {
				return err
			}
			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 *BasicSummaryEntry) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.MonetaryValue.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "monetary_value",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *BillArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s BillRepeatFrequency) Validate() error {
	switch s {
	case "weekly":
		return nil
	case "monthly":
		return nil
	case "quarterly":
		return nil
	case "half-year":
		return nil
	case "yearly":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

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

func (s *BillUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.RepeatFreq.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:  "repeat_freq",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *Budget) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.AutoBudgetType.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:  "auto_budget_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AutoBudgetPeriod.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:  "auto_budget_period",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *BudgetArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *BudgetLimitArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

func (s *BudgetStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.AutoBudgetType.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:  "auto_budget_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AutoBudgetPeriod.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:  "auto_budget_period",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *BudgetUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.AutoBudgetType.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:  "auto_budget_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.AutoBudgetPeriod.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:  "auto_budget_period",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *CategoryArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ChartLine) Validate() error {
	alias := ([]ChartDataSet)(s)
	if alias == nil {
		return errors.New("nil is invalid value")
	}
	return nil
}

func (s ConfigValueFilter) Validate() error {
	switch s {
	case "configuration.is_demo_site":
		return nil
	case "configuration.permission_update_check":
		return nil
	case "configuration.last_update_check":
		return nil
	case "configuration.single_user_mode":
		return nil
	case "firefly.version":
		return nil
	case "firefly.api_version":
		return nil
	case "firefly.default_location":
		return nil
	case "firefly.account_to_transaction":
		return nil
	case "firefly.allowed_opposing_types":
		return nil
	case "firefly.accountRoles":
		return nil
	case "firefly.valid_liabilities":
		return nil
	case "firefly.interest_periods":
		return nil
	case "firefly.enable_external_map":
		return nil
	case "firefly.expected_source_types":
		return nil
	case "app.timezone":
		return nil
	case "firefly.bill_periods":
		return nil
	case "firefly.credit_card_types":
		return nil
	case "firefly.languages":
		return nil
	case "firefly.valid_view_ranges":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s ConfigValueUpdateFilter) Validate() error {
	switch s {
	case "configuration.is_demo_site":
		return nil
	case "configuration.permission_update_check":
		return nil
	case "configuration.last_update_check":
		return nil
	case "configuration.single_user_mode":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *Configuration) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Title.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "title",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Value.Validate(); err != nil {
			return err
		}
		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 ConfigurationArray) Validate() error {
	alias := ([]Configuration)(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 *ConfigurationSingle) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Data.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ConfigurationUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Value.Validate(); err != nil {
			return err
		}
		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 CreditCardType) Validate() error {
	switch s {
	case "monthlyFull":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *CurrencyArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *CurrencyUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Default.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:  "default",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s DataDestroyObject) Validate() error {
	switch s {
	case "not_assets_liabilities":
		return nil
	case "budgets":
		return nil
	case "bills":
		return nil
	case "piggy_banks":
		return nil
	case "rules":
		return nil
	case "recurring":
		return nil
	case "categories":
		return nil
	case "tags":
		return nil
	case "object_groups":
		return nil
	case "accounts":
		return nil
	case "asset_accounts":
		return nil
	case "expense_accounts":
		return nil
	case "revenue_accounts":
		return nil
	case "liabilities":
		return nil
	case "transactions":
		return nil
	case "withdrawals":
		return nil
	case "deposits":
		return nil
	case "transfers":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

func (s InsightGroup) Validate() error {
	alias := ([]InsightGroupEntry)(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 *InsightGroupEntry) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.DifferenceFloat.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "difference_float",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s InsightTotal) Validate() error {
	alias := ([]InsightTotalEntry)(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 *InsightTotalEntry) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.DifferenceFloat.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "difference_float",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s InsightTransfer) Validate() error {
	alias := ([]InsightTransferEntry)(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 *InsightTransferEntry) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.DifferenceFloat.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "difference_float",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.InFloat.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "in_float",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.OutFloat.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "out_float",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s InterestPeriod) Validate() error {
	switch s {
	case "weekly":
		return nil
	case "monthly":
		return nil
	case "quarterly":
		return nil
	case "half-year":
		return nil
	case "yearly":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

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

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

func (s *LinkTypeArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *ObjectGroupArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PiggyBank) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Percentage.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "percentage",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PiggyBankArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *PiggyBankEventArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

func (s PolymorphicProperty) Validate() error {
	switch s.Type {
	case BoolPolymorphicProperty:
		return nil // no validation needed
	case StringPolymorphicProperty:
		return nil // no validation needed
	case PolymorphicProperty2PolymorphicProperty:
		return nil // no validation needed
	case StringArrayItemArrayPolymorphicProperty:
		if s.StringArrayItemArray == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

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

func (s *PreferenceArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

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

func (s *Recurrence) Validate() error {
	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 {
		var failures []validate.FieldError
		for i, elem := range s.Repetitions {
			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:  "repetitions",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RecurrenceArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *RecurrenceRepetition) Validate() error {
	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 *RecurrenceRepetitionStore) Validate() error {
	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 RecurrenceRepetitionType) Validate() error {
	switch s {
	case "daily":
		return nil
	case "weekly":
		return nil
	case "ndom":
		return nil
	case "monthly":
		return nil
	case "yearly":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RecurrenceRepetitionUpdate) Validate() error {
	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 len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *RecurrenceStore) Validate() error {
	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.Repetitions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Repetitions {
			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:  "repetitions",
			Error: err,
		})
	}
	if err := func() error {
		if s.Transactions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RecurrenceTransaction) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.SourceType.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_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.DestinationType.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:  "destination_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RecurrenceTransactionStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *RecurrenceTransactionUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RecurrenceUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Repetitions {
			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:  "repetitions",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *Rule) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Trigger.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		if s.Triggers == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Triggers {
			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:  "triggers",
			Error: err,
		})
	}
	if err := func() error {
		if s.Actions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Actions {
			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:  "actions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RuleAction) Validate() error {
	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 RuleActionKeyword) Validate() error {
	switch s {
	case "user_action":
		return nil
	case "set_category":
		return nil
	case "clear_category":
		return nil
	case "set_budget":
		return nil
	case "clear_budget":
		return nil
	case "add_tag":
		return nil
	case "remove_tag":
		return nil
	case "remove_all_tags":
		return nil
	case "set_description":
		return nil
	case "append_description":
		return nil
	case "prepend_description":
		return nil
	case "set_source_account":
		return nil
	case "set_destination_account":
		return nil
	case "set_notes":
		return nil
	case "append_notes":
		return nil
	case "prepend_notes":
		return nil
	case "clear_notes":
		return nil
	case "link_to_bill":
		return nil
	case "convert_withdrawal":
		return nil
	case "convert_deposit":
		return nil
	case "convert_transfer":
		return nil
	case "delete_transaction":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RuleActionStore) Validate() error {
	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 *RuleActionUpdate) Validate() error {
	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 len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RuleArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RuleGroupArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

func (s *RuleStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Trigger.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		if s.Triggers == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Triggers {
			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:  "triggers",
			Error: err,
		})
	}
	if err := func() error {
		if s.Actions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Actions {
			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:  "actions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RuleTrigger) Validate() error {
	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 RuleTriggerKeyword) Validate() error {
	switch s {
	case "from_account_starts":
		return nil
	case "from_account_ends":
		return nil
	case "from_account_is":
		return nil
	case "from_account_contains":
		return nil
	case "to_account_starts":
		return nil
	case "to_account_ends":
		return nil
	case "to_account_is":
		return nil
	case "to_account_contains":
		return nil
	case "amount_less":
		return nil
	case "amount_exactly":
		return nil
	case "amount_more":
		return nil
	case "description_starts":
		return nil
	case "description_ends":
		return nil
	case "description_contains":
		return nil
	case "description_is":
		return nil
	case "transaction_type":
		return nil
	case "category_is":
		return nil
	case "budget_is":
		return nil
	case "tag_is":
		return nil
	case "currency_is":
		return nil
	case "has_attachments":
		return nil
	case "has_no_category":
		return nil
	case "has_any_category":
		return nil
	case "has_no_budget":
		return nil
	case "has_any_budget":
		return nil
	case "has_no_tag":
		return nil
	case "has_any_tag":
		return nil
	case "notes_contains":
		return nil
	case "notes_start":
		return nil
	case "notes_end":
		return nil
	case "notes_are":
		return nil
	case "no_notes":
		return nil
	case "any_notes":
		return nil
	case "source_account_is":
		return nil
	case "destination_account_is":
		return nil
	case "source_account_starts":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RuleTriggerStore) Validate() error {
	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 RuleTriggerType) Validate() error {
	switch s {
	case "store-journal":
		return nil
	case "update-journal":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *RuleTriggerUpdate) Validate() error {
	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 len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *RuleUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Trigger.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:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Triggers {
			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:  "triggers",
			Error: err,
		})
	}
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Actions {
			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:  "actions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s ShortAccountTypeProperty) Validate() error {
	switch s {
	case "asset":
		return nil
	case "expense":
		return nil
	case "import":
		return nil
	case "revenue":
		return nil
	case "cash":
		return nil
	case "liability":
		return nil
	case "liabilities":
		return nil
	case "initial-balance":
		return nil
	case "reconciliation":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *TagArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TagModel) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TagModelStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TagModelUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

func (s *Transaction) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Transactions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransactionArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransactionLinkArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

func (s *TransactionSplit) Validate() error {
	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.SourceType.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_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.DestinationType.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:  "destination_type",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Latitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "latitude",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Longitude.Get(); ok {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "longitude",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransactionSplitStore) Validate() error {
	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.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransactionSplitUpdate) Validate() error {
	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.Tags.Get(); ok {
			if err := func() error {
				if value == nil {
					return errors.New("nil is invalid value")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "tags",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *TransactionStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Transactions == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s TransactionTypeFilter) Validate() error {
	switch s {
	case "all":
		return nil
	case "withdrawal":
		return nil
	case "withdrawals":
		return nil
	case "expense":
		return nil
	case "deposit":
		return nil
	case "deposits":
		return nil
	case "income":
		return nil
	case "transfer":
		return nil
	case "transfers":
		return nil
	case "opening_balance":
		return nil
	case "reconciliation":
		return nil
	case "special":
		return nil
	case "specials":
		return nil
	case "default":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s TransactionTypeProperty) Validate() error {
	switch s {
	case "withdrawal":
		return nil
	case "deposit":
		return nil
	case "transfer":
		return nil
	case "reconciliation":
		return nil
	case "opening balance":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}

func (s *TransactionUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.Transactions {
			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:  "transactions",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *User) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.String{
			MinLength:    0,
			MinLengthSet: false,
			MaxLength:    0,
			MaxLengthSet: false,
			Email:        true,
			Hostname:     false,
			Regex:        nil,
		}).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 err := func() error {
		if value, ok := s.BlockedCode.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:  "blocked_code",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Role.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:  "role",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *UserArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

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

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

func (s *Webhook) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Trigger.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Response.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Delivery.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "delivery",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *WebhookArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Data {
			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:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

func (s *WebhookAttemptArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *WebhookMessageArray) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Data == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "data",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

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

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

func (s *WebhookStore) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Trigger.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Response.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response",
			Error: err,
		})
	}
	if err := func() error {
		if err := s.Delivery.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "delivery",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}

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

func (s *WebhookUpdate) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if value, ok := s.Trigger.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:  "trigger",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Response.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:  "response",
			Error: err,
		})
	}
	if err := func() error {
		if value, ok := s.Delivery.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:  "delivery",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}