schema

type Body struct {
	Value  json.RawMessage
	Schema *Schema
}

type Discriminator struct {
	// PropertyName is the JSON property name that holds the discriminator value
	PropertyName string

	// Mapping maps discriminator values to property names in the schema
	// For example: {"simple": "nodeType", "compound": "nodeType"}
	// The keys are the valid discriminator values
	Mapping map[string]string
}

type GeneratedRequest struct {
	Path        string          `json:"path"`
	ContentType string          `json:"contentType,omitempty"`
	Headers     any             `json:"headers,omitempty"`
	Body        json.RawMessage `json:"body,omitempty"`
}

type Headers struct {
	Value  http.Header
	Schema *Schema
}

type Operation struct {
	ID string `json:"id,omitempty"`

	// Content-Type of the request body (e.g., "application/json")
	ContentType string          `json:"contentType,omitempty"`
	Method      string          `json:"method,omitempty"`
	Path        string          `json:"path,omitempty"`
	PathParams  *Schema         `json:"pathParams,omitempty"`
	Query       QueryParameters `json:"query,omitempty"`
	Headers     *Schema         `json:"headers,omitempty"`
	Body        *Schema         `json:"body,omitempty"`

	// Encoding metadata for form fields
	BodyEncoding map[string]codegen.RequestBodyEncoding `json:"bodyEncoding,omitempty"`
	Response     *Response                              `json:"response,omitempty"`
}

type Parameter struct {
	Type  ParameterType
	Value any
}

type ParameterType string

type Path struct {
	Value   string
	Schema  *Schema
	Pattern string
}

type Query struct {
	Value  string
	Schema *Schema
}

type QueryParameter struct {
	Schema   *Schema                    `json:"schema,omitempty"`
	Required bool                       `json:"required,omitempty"`
	Encoding *codegen.ParameterEncoding `json:"encoding,omitempty"`
}

type QueryParameters map[string]*QueryParameter

type RequestData struct {
	Method     string                // HTTP method (GET, POST, PUT, etc.)
	ResourceID string                // The operation path pattern with placeholders (e.g., /users/{id})
	Params     map[string]*Parameter // All parameters (path, query, header) with their types
	Body       any                   // Parsed request body (can be map[string]any for objects, []any for arrays, or primitives)
}

type RequestSchema struct {
	URL     string
	Method  string
	Path    *Path
	Body    *Body
	Query   *Query
	Headers *Headers
}

type Response struct {
	All         map[int]*ResponseItem `json:"all.omitempty"`
	SuccessCode int                   `json:"successCode,omitempty"`
}

type ResponseData struct {
	Body    json.RawMessage `json:"body,omitempty"`
	Headers http.Header     `json:"headers,omitempty"`
	IsError bool            `json:"isError,omitempty"`
}

type ResponseItem struct {
	Headers     map[string]*Schema `json:"headers,omitempty"`
	Content     *Schema            `json:"content,omitempty"`
	ContentType string             `json:"contentType,omitempty"`
	StatusCode  int                `json:"statusCode,omitempty"`
}

type ResponseSchema struct {
	ContentType string
	Body        *Schema
	Headers     map[string]*Schema
	Error       *Schema
}

type Schema struct {
	Type string `yaml:"type,omitempty"`

	// in 3.1 examples can be an array (which is recommended)
	Examples []any `yaml:"examples,omitempty"`

	// items can be a schema in 2.0, 3.0 and 3.1 or a bool in 3.1
	Items *Schema `yaml:"items,omitempty"`

	// Compatible with all versions
	MultipleOf           *float64           `yaml:"multipleOf,omitempty"`
	Maximum              *float64           `yaml:"maximum,omitempty"`
	ExclusiveMaximum     *float64           `yaml:"exclusiveMaximum,omitempty"`
	Minimum              *float64           `yaml:"minimum,omitempty"`
	ExclusiveMinimum     *float64           `yaml:"exclusiveMinimum,omitempty"`
	MaxLength            *int64             `yaml:"maxLength,omitempty"`
	MinLength            *int64             `yaml:"minLength,omitempty"`
	Pattern              string             `yaml:"pattern,omitempty"`
	Format               string             `yaml:"format,omitempty"`
	MaxItems             *int64             `yaml:"maxItems,omitempty"`
	MinItems             *int64             `yaml:"minItems,omitempty"`
	MaxProperties        *int64             `yaml:"maxProperties,omitempty"`
	MinProperties        *int64             `yaml:"minProperties,omitempty"`
	Required             []string           `yaml:"required,omitempty"`
	Enum                 []any              `yaml:"enum,omitempty"`
	Properties           map[string]*Schema `yaml:"properties,omitempty"`
	Default              any                `yaml:"default,omitempty"`
	Nullable             bool               `yaml:"nullable,omitempty"`
	ReadOnly             bool               `yaml:"readOnly,omitempty"`
	WriteOnly            bool               `yaml:"writeOnly,omitempty"`
	Example              any                `yaml:"example,omitempty"`
	Deprecated           bool               `yaml:"deprecated,omitempty"`
	AdditionalProperties *Schema            `yaml:"additionalProperties,omitempty"`

	// Discriminator describes the discriminator for oneOf/anyOf schemas.
	// When set, the generator should use one of the valid discriminator values
	// for the discriminator property instead of generating a random value.
	Discriminator *Discriminator `yaml:"-" json:"-"`

	// Recursive indicates this schema was truncated due to circular reference.
	// The content generator should return nil for such schemas.
	Recursive bool `yaml:"-" json:"-"`

	// StaticContent holds pre-rendered content for static responses.
	// When set, the generator should return this content directly instead of generating.
	// This is used for static services where responses are pre-defined files.
	StaticContent string `yaml:"-" json:"-"`
}