oas_validators_gen.go

// Code generated by ogen, DO NOT EDIT.

package go_openaiclient

import (
	"fmt"

	"github.com/go-faster/errors"

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

func (s *ChatCompletionRequestMessage) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Role.Validate(); 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 ChatCompletionRequestMessageRole) Validate() error {
	switch s {
	case "system":
		return nil
	case "user":
		return nil
	case "assistant":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s *ChatCompletionResponseMessage) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Role.Validate(); 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 ChatCompletionResponseMessageRole) Validate() error {
	switch s {
	case "system":
		return nil
	case "user":
		return nil
	case "assistant":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s *CreateChatCompletionRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Messages == nil {
			return errors.New("nil is invalid value")
		}
		if err := (validate.Array{
			MinLength:    1,
			MinLengthSet: true,
			MaxLength:    0,
			MaxLengthSet: false,
		}).ValidateLength(len(s.Messages)); err != nil {
			return errors.Wrap(err, "array")
		}
		var failures []validate.FieldError
		for i, elem := range s.Messages {
			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:  "messages",
			Error: err,
		})
	}
	if err := func() error {
		if s.Temperature.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           2,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.Temperature.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "temperature",
			Error: err,
		})
	}
	if err := func() error {
		if s.TopP.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           1,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.TopP.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "top_p",
			Error: err,
		})
	}
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           128,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Stop.Set {
			if err := func() error {
				if err := s.Stop.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "stop",
			Error: err,
		})
	}
	if err := func() error {
		if s.PresencePenalty.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           -2,
					MaxSet:        true,
					Max:           2,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.PresencePenalty.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "presence_penalty",
			Error: err,
		})
	}
	if err := func() error {
		if s.FrequencyPenalty.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           -2,
					MaxSet:        true,
					Max:           2,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.FrequencyPenalty.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "frequency_penalty",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s CreateChatCompletionRequestStop) Validate() error {
	switch s.Type {
	case NullCreateChatCompletionRequestStop:
		return nil // no validation needed
	case StringCreateChatCompletionRequestStop:
		return nil // no validation needed
	case StringArrayCreateChatCompletionRequestStop:
		if s.StringArray == nil {
			return errors.New("nil is invalid value")
		}
		if err := (validate.Array{
			MinLength:    1,
			MinLengthSet: true,
			MaxLength:    4,
			MaxLengthSet: true,
		}).ValidateLength(len(s.StringArray)); err != nil {
			return errors.Wrap(err, "array")
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *CreateChatCompletionResponse) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Choices == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Choices {
			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:  "choices",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateChatCompletionResponseChoicesItem) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Message.Set {
			if err := func() error {
				if err := s.Message.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "message",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateEditRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           20,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Temperature.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           2,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.Temperature.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "temperature",
			Error: err,
		})
	}
	if err := func() error {
		if s.TopP.Set {
			if err := func() error {
				if err := (validate.Float{
					MinSet:        true,
					Min:           0,
					MaxSet:        true,
					Max:           1,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    nil,
				}).Validate(float64(s.TopP.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "top_p",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateEditResponse) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Choices == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Choices {
			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:  "choices",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateEditResponseChoicesItem) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Logprobs.Set {
			if err := func() error {
				if err := s.Logprobs.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "logprobs",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateEditResponseChoicesItemLogprobs) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		var failures []validate.FieldError
		for i, elem := range s.TokenLogprobs {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(elem)); err != nil {
					return errors.Wrap(err, "float")
				}
				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:  "token_logprobs",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateFineTuneRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.LearningRateMultiplier.Set {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(s.LearningRateMultiplier.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "learning_rate_multiplier",
			Error: err,
		})
	}
	if err := func() error {
		if s.PromptLossWeight.Set {
			if err := func() error {
				if err := (validate.Float{}).Validate(float64(s.PromptLossWeight.Value)); err != nil {
					return errors.Wrap(err, "float")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "prompt_loss_weight",
			Error: err,
		})
	}
	if err := func() error {
		if s.ClassificationBetas.Set {
			if err := func() error {
				if s.ClassificationBetas.Value == nil {
					return errors.New("nil is invalid value")
				}
				var failures []validate.FieldError
				for i, elem := range s.ClassificationBetas.Value {
					if err := func() error {
						if err := (validate.Float{}).Validate(float64(elem)); err != nil {
							return errors.Wrap(err, "float")
						}
						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 {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "classification_betas",
			Error: err,
		})
	}
	if err := func() error {
		if s.Suffix.Set {
			if err := func() error {
				if err := (validate.String{
					MinLength:    1,
					MinLengthSet: true,
					MaxLength:    40,
					MaxLengthSet: true,
					Email:        false,
					Hostname:     false,
					Regex:        nil,
				}).Validate(string(s.Suffix.Value)); err != nil {
					return errors.Wrap(err, "string")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "suffix",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateImageEditRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           10,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Size.Set {
			if err := func() error {
				if err := s.Size.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "size",
			Error: err,
		})
	}
	if err := func() error {
		if s.ResponseFormat.Set {
			if err := func() error {
				if err := s.ResponseFormat.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response_format",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateImageEditRequestForm) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           10,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Size.Set {
			if err := func() error {
				if err := s.Size.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "size",
			Error: err,
		})
	}
	if err := func() error {
		if s.ResponseFormat.Set {
			if err := func() error {
				if err := s.ResponseFormat.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response_format",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s CreateImageEditRequestResponseFormat) Validate() error {
	switch s {
	case "url":
		return nil
	case "b64_json":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s CreateImageEditRequestSize) Validate() error {
	switch s {
	case "256x256":
		return nil
	case "512x512":
		return nil
	case "1024x1024":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s *CreateImageRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           10,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Size.Set {
			if err := func() error {
				if err := s.Size.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "size",
			Error: err,
		})
	}
	if err := func() error {
		if s.ResponseFormat.Set {
			if err := func() error {
				if err := s.ResponseFormat.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response_format",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s CreateImageRequestResponseFormat) Validate() error {
	switch s {
	case "url":
		return nil
	case "b64_json":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s CreateImageRequestSize) Validate() error {
	switch s {
	case "256x256":
		return nil
	case "512x512":
		return nil
	case "1024x1024":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s *CreateImageVariationRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           10,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Size.Set {
			if err := func() error {
				if err := s.Size.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "size",
			Error: err,
		})
	}
	if err := func() error {
		if s.ResponseFormat.Set {
			if err := func() error {
				if err := s.ResponseFormat.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response_format",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateImageVariationRequestForm) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.N.Set {
			if err := func() error {
				if err := (validate.Int{
					MinSet:        true,
					Min:           1,
					MaxSet:        true,
					Max:           10,
					MinExclusive:  false,
					MaxExclusive:  false,
					MultipleOfSet: false,
					MultipleOf:    0,
				}).Validate(int64(s.N.Value)); err != nil {
					return errors.Wrap(err, "int")
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "n",
			Error: err,
		})
	}
	if err := func() error {
		if s.Size.Set {
			if err := func() error {
				if err := s.Size.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "size",
			Error: err,
		})
	}
	if err := func() error {
		if s.ResponseFormat.Set {
			if err := func() error {
				if err := s.ResponseFormat.Value.Validate(); err != nil {
					return err
				}
				return nil
			}(); err != nil {
				return err
			}
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "response_format",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s CreateImageVariationRequestResponseFormat) Validate() error {
	switch s {
	case "url":
		return nil
	case "b64_json":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s CreateImageVariationRequestSize) Validate() error {
	switch s {
	case "256x256":
		return nil
	case "512x512":
		return nil
	case "1024x1024":
		return nil
	default:
		return errors.Errorf("invalid value: %v", s)
	}
}
func (s *CreateModerationRequest) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.Input.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "input",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s CreateModerationRequestInput) Validate() error {
	switch s.Type {
	case StringCreateModerationRequestInput:
		return nil // no validation needed
	case StringArrayCreateModerationRequestInput:
		if s.StringArray == nil {
			return errors.New("nil is invalid value")
		}
		return nil
	default:
		return errors.Errorf("invalid type %q", s.Type)
	}
}

func (s *CreateModerationResponse) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if s.Results == nil {
			return errors.New("nil is invalid value")
		}
		var failures []validate.FieldError
		for i, elem := range s.Results {
			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:  "results",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateModerationResponseResultsItem) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := s.CategoryScores.Validate(); err != nil {
			return err
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "category_scores",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *CreateModerationResponseResultsItemCategoryScores) Validate() error {
	var failures []validate.FieldError
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.Hate)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "hate",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.HateSlashThreatening)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "hate/threatening",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.SelfMinusHarm)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "self-harm",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.Sexual)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "sexual",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.SexualSlashMinors)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "sexual/minors",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.Violence)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "violence",
			Error: err,
		})
	}
	if err := func() error {
		if err := (validate.Float{}).Validate(float64(s.ViolenceSlashGraphic)); err != nil {
			return errors.Wrap(err, "float")
		}
		return nil
	}(); err != nil {
		failures = append(failures, validate.FieldError{
			Name:  "violence/graphic",
			Error: err,
		})
	}
	if len(failures) > 0 {
		return &validate.Error{Fields: failures}
	}
	return nil
}
func (s *ListFilesResponse) 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 *ListFineTuneEventsResponse) 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 *ListFineTunesResponse) 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 *ListModelsResponse) 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
}