codegen

type AllOfMergeError struct {
	SchemaName   string
	PropertyName string
	Type1        string
	Type2        string
}

type ClientGenerator struct {
	// contains filtered or unexported fields
}

type CodeBuilder struct {
	// contains filtered or unexported fields
}

type CodegenContext struct {
	// contains filtered or unexported fields
}

type Configuration struct {
	// PackageName which will be used in all generated files
	PackageName string `yaml:"package"`
	// Output specifies the output file path
	Output string `yaml:"output"`
	// Generation controls which parts of the code are generated
	Generation GenerationOptions `yaml:"generation,omitempty"`
	// OutputOptions controls filtering of operations and schemas
	OutputOptions OutputOptions `yaml:"output-options,omitempty"`
	// TypeMapping allows customizing OpenAPI type/format to Go type mappings
	TypeMapping TypeMapping `yaml:"type-mapping,omitempty"`
	// NameMangling configures how OpenAPI names are converted to Go identifiers
	NameMangling NameMangling `yaml:"name-mangling,omitempty"`
	// NameSubstitutions allows direct overrides of generated names
	NameSubstitutions NameSubstitutions `yaml:"name-substitutions,omitempty"`
	// ImportMapping maps external spec file paths to Go package import paths.
	// The value is either a bare import path or "alias importpath".
	// Examples:
	//   "../common/api.yaml": "github.com/org/project/common"         # alias auto-generated via hash
	//   "../common/api.yaml": "common github.com/org/project/common"  # explicit alias "common"
	// Use "-" as the value to indicate types should be in the current package.
	ImportMapping map[string]string `yaml:"import-mapping,omitempty"`
	// ContentTypes is a list of regexp patterns for media types to generate models for.
	// Only request/response bodies with matching content types will have types generated.
	// Defaults to common JSON and YAML types if not specified.
	ContentTypes []string `yaml:"content-types,omitempty"`
	// ContentTypeShortNames maps short names to lists of content type regex patterns.
	// Example: {"JSON": ["^application/json$", "^application/.*\\+json$"]}
	// These are used when generating response/request type names like "FindPetsJSONResponse".
	ContentTypeShortNames map[string][]string `yaml:"content-type-short-names,omitempty"`
	// StructTags configures how struct tags are generated for fields.
	// By default, only json tags are generated.
	StructTags StructTagsConfig `yaml:"struct-tags,omitempty"`
}

type ContentTypeMatcher struct {
	// contains filtered or unexported fields
}

type ContentTypeShortNamer struct {
	// contains filtered or unexported fields
}

type DiscriminatorInfo struct {
	// PropertyName is the JSON property used as the discriminator (e.g., "petType").
	PropertyName string

	// Mapping maps discriminator values to $ref paths.
	// For explicit mappings, keys are the values from the spec's discriminator.mapping.
	// For implicit mappings, keys are inferred from $ref schema names.
	Mapping map[string]string

	// IsExplicit is true when the spec includes a discriminator.mapping section.
	IsExplicit bool
}

type EnumInfo struct {
	// TypeName is the Go type name for the enum (e.g., "Color", "Status").
	TypeName string
	// BaseType is the Go base type (e.g., "string", "int").
	BaseType string
	// Values are the raw enum values from the spec.
	Values []string
	// CustomNames are user-provided constant names from x-oapi-codegen-enum-var-names.
	// May be nil or shorter than Values.
	CustomNames []string
	// Doc is the enum's documentation string.
	Doc string
	// SchemaPath is the key used to look up this EnumInfo (schema path string).
	SchemaPath string

	// PrefixTypeName indicates whether constant names should be prefixed with the type name.
	// Set by resolveEnumCollisions when collisions are detected.
	PrefixTypeName bool
	// SanitizedNames are the computed constant name suffixes (without type prefix).
	// Populated by computeEnumConstantNames.
	SanitizedNames []string
}

type Extensions struct {
	TypeOverride        *TypeOverride // External type to use
	NameOverride        string        // Override field name
	TypeNameOverride    string        // Override generated type name
	SkipOptionalPointer *bool         // Skip pointer for optional fields
	JSONIgnore          *bool         // Exclude from JSON
	OmitEmpty           *bool         // Control omitempty
	OmitZero            *bool         // Control omitzero
	EnumVarNames        []string      // Override enum constant names
	DeprecatedReason    string        // Deprecation reason
	Order               *int          // Field ordering
}

type ExternalImport struct {
	Alias string // Short alias for use in generated code (e.g., "ext_a1b2c3")
	Path  string // Full import path (e.g., "github.com/org/project/common")
}

type FormatMapping struct {
	Default SimpleTypeSpec            `yaml:"default"`
	Formats map[string]SimpleTypeSpec `yaml:"formats,omitempty"`
}

type GenerationOptions struct {
	// Server specifies which server framework to generate code for.
	// Supported values: "std-http"
	// Empty string (default) means no server code is generated.
	Server string `yaml:"server,omitempty"`

	// Client enables generation of the HTTP client.
	// When true, generates a base Client that returns *http.Response.
	Client bool `yaml:"client,omitempty"`

	// SimpleClient enables generation of the SimpleClient wrapper.
	// SimpleClient wraps the base Client with typed responses for
	// operations that have unambiguous response types.
	// Requires Client to also be enabled.
	SimpleClient bool `yaml:"simple-client,omitempty"`

	// WebhookInitiator enables generation of webhook initiator code (sends webhook requests).
	// Generates a framework-agnostic client that takes the full target URL per-call.
	WebhookInitiator bool `yaml:"webhook-initiator,omitempty"`

	// WebhookReceiver enables generation of webhook receiver code (receives webhook requests).
	// Generates framework-specific handler functions. Requires Server to be set.
	WebhookReceiver bool `yaml:"webhook-receiver,omitempty"`

	// CallbackInitiator enables generation of callback initiator code (sends callback requests).
	// Generates a framework-agnostic client that takes the full target URL per-call.
	CallbackInitiator bool `yaml:"callback-initiator,omitempty"`

	// CallbackReceiver enables generation of callback receiver code (receives callback requests).
	// Generates framework-specific handler functions. Requires Server to be set.
	CallbackReceiver bool `yaml:"callback-receiver,omitempty"`

	// ModelsPackage specifies an external package containing the model types.
	// When set, models are NOT generated locally - instead, generated code
	// imports and references types from this package.
	// Example: {path: "github.com/org/project/models"}
	ModelsPackage *ModelsPackage `yaml:"models-package,omitempty"`

	// RuntimePackage specifies an external package containing runtime helpers
	// (Date, Nullable, param style/bind functions, marshalForm, etc.).
	// When set, these helpers are NOT embedded in the generated output —
	// instead, generated code imports and references them from this package.
	// Generate the runtime package with --generate-runtime or GenerateRuntime().
	RuntimePackage *RuntimePackageConfig `yaml:"runtime-package,omitempty"`
}

type ImportResolver struct {
	// contains filtered or unexported fields
}

type InitiatorGenerator struct {
	// contains filtered or unexported fields
}

type ModelsPackage struct {
	// Path is the import path for the models package (e.g., "github.com/org/project/models")
	Path string `yaml:"path"`
	// Alias is an optional import alias. If empty, the last segment of the path is used.
	Alias string `yaml:"alias,omitempty"`
}

type NameConverter struct {
	// contains filtered or unexported fields
}

type NameMangling struct {
	// CharacterSubstitutions maps characters to their word replacements.
	// Used when these characters appear at the start of a name.
	// Example: '$' -> "DollarSign", '-' -> "Minus"
	CharacterSubstitutions map[string]string `yaml:"character-substitutions,omitempty"`

	// WordSeparators is a string of characters that mark word boundaries.
	// When encountered, the next letter is capitalized.
	// Example: "-_. " means "foo-bar" becomes "FooBar"
	WordSeparators string `yaml:"word-separators,omitempty"`

	// NumericPrefix is prepended when a name starts with a digit.
	// Example: "N" means "123foo" becomes "N123foo"
	NumericPrefix string `yaml:"numeric-prefix,omitempty"`

	// KeywordPrefix is prepended when a name conflicts with a Go keyword.
	// Example: "_" means "type" becomes "_type"
	KeywordPrefix string `yaml:"keyword-prefix,omitempty"`

	// Initialisms is a list of words that should be all-uppercase.
	// Example: ["ID", "HTTP", "URL"] means "userId" becomes "UserID"
	Initialisms []string `yaml:"initialisms,omitempty"`
}

type NameSubstitutions struct {
	// TypeNames maps generated type names to user-preferred names.
	// Example: {"MyGeneratedType": "MyPreferredName"}
	TypeNames map[string]string `yaml:"type-names,omitempty"`

	// PropertyNames maps generated property/field names to user-preferred names.
	// Example: {"GeneratedField": "PreferredField"}
	PropertyNames map[string]string `yaml:"property-names,omitempty"`
}

type OperationDescriptor struct {
	OperationID   string // Normalized operation ID for function names
	GoOperationID string // Go-safe identifier (handles leading digits, keywords)
	Method        string // HTTP method: GET, POST, PUT, DELETE, etc.
	Path          string // Original path: /users/{id}
	Summary       string // For generating comments
	Description   string // Longer description

	// Source indicates where this operation was defined (path, webhook, or callback)
	Source       OperationSource
	WebhookName  string // Webhook name (for Source=webhook)
	CallbackName string // Callback key (for Source=callback)
	ParentOpID   string // Parent operation ID (for Source=callback)

	PathParams   []*ParameterDescriptor
	QueryParams  []*ParameterDescriptor
	HeaderParams []*ParameterDescriptor
	CookieParams []*ParameterDescriptor

	Bodies    []*RequestBodyDescriptor
	Responses []*ResponseDescriptor

	Security []SecurityRequirement

	// Precomputed for templates
	HasBody        bool   // Has at least one request body
	HasParams      bool   // Has non-path params (needs Params struct)
	ParamsTypeName string // "{OperationID}Params"

	// Reference to the underlying spec
	Spec *v3.Operation
}

type OperationSource string

type Output struct {
	// contains filtered or unexported fields
}

type OutputOptions struct {
	// IncludeTags only includes operations tagged with one of these tags. Ignored when empty.
	IncludeTags []string `yaml:"include-tags,omitempty"`
	// ExcludeTags excludes operations tagged with one of these tags. Ignored when empty.
	ExcludeTags []string `yaml:"exclude-tags,omitempty"`
	// IncludeOperationIDs only includes operations with one of these operation IDs. Ignored when empty.
	IncludeOperationIDs []string `yaml:"include-operation-ids,omitempty"`
	// ExcludeOperationIDs excludes operations with one of these operation IDs. Ignored when empty.
	ExcludeOperationIDs []string `yaml:"exclude-operation-ids,omitempty"`
	// ExcludeSchemas excludes schemas with the given names from generation. Ignored when empty.
	ExcludeSchemas []string `yaml:"exclude-schemas,omitempty"`
	// PruneUnreferencedSchemas removes component schemas that are not $ref'd by any other
	// gathered schema. When combined with tag/operation filtering, this effectively removes
	// schemas that are only used by excluded operations.
	PruneUnreferencedSchemas bool `yaml:"prune-unreferenced-schemas,omitempty"`
	// AlwaysPrefixEnumValues forces all enum constants to be prefixed with the type name,
	// regardless of whether cross-enum collisions are detected.
	// When false (default), enum constants are only prefixed when needed to avoid collisions.
	AlwaysPrefixEnumValues bool `yaml:"always-prefix-enum-values,omitempty"`
}

type ParameterDescriptor struct {
	Name     string // Original name from spec (e.g., "user_id")
	GoName   string // Go-safe name for struct fields (e.g., "UserId")
	Location string // "path", "query", "header", "cookie"
	Required bool

	// Serialization style
	Style   string // "simple", "form", "label", "matrix", etc.
	Explode bool

	// Type information
	Schema   *SchemaDescriptor
	TypeDecl string // Go type declaration (e.g., "string", "[]int", "*MyType")

	// Encoding modes
	IsStyled      bool // Uses style/explode serialization (most common)
	IsPassThrough bool // No styling, just pass the string through
	IsJSON        bool // Parameter uses JSON content encoding

	Spec *v3.Parameter
}

type ReceiverGenerator struct {
	// contains filtered or unexported fields
}

type ReceiverTemplateData struct {
	Prefix      string                 // "Webhook" or "Callback"
	PrefixLower string                 // "webhook" or "callback"
	Operations  []*OperationDescriptor // Operations to generate for
}

type RequestBodyDescriptor struct {
	ContentType string // "application/json", "multipart/form-data", etc.
	Required    bool
	Schema      *SchemaDescriptor

	// Precomputed for templates
	NameTag       string // "JSON", "Formdata", "Multipart", "Text", etc.
	GoTypeName    string // "{OperationID}JSONBody", etc.
	FuncSuffix    string // "", "WithJSONBody", "WithFormBody" (empty for default)
	IsDefault     bool   // Is this the default body type?
	IsFormEncoded bool   // Is this application/x-www-form-urlencoded?
	GenerateTyped bool   // Generate typed methods for this body (based on content-types config)

	// Encoding options for form data
	Encoding map[string]RequestBodyEncoding
}

type RequestBodyEncoding struct {
	ContentType string
	Style       string
	Explode     *bool
}

type ResponseContentDescriptor struct {
	ContentType string
	Schema      *SchemaDescriptor
	NameTag     string // "JSON", "XML", etc.
	IsJSON      bool
}

type ResponseDescriptor struct {
	StatusCode  string // "200", "404", "default", "2XX"
	Description string
	Contents    []*ResponseContentDescriptor
	Headers     []*ResponseHeaderDescriptor
	Ref         string // If this is a reference to a named response
}

type ResponseHeaderDescriptor struct {
	Name     string
	GoName   string
	Required bool
	Schema   *SchemaDescriptor
}

type RuntimeOutput struct {
	Params  string // params sub-package (style/bind functions, helpers)
	Types   string // types sub-package (Date, Email, UUID, File, Nullable)
	Helpers string // helpers sub-package (MarshalForm)
}

type RuntimePackageConfig struct {
	// Path is the base import path for the runtime package
	// (e.g., "github.com/org/project/runtime").
	// Sub-packages are at Path/types, Path/params, and Path/helpers.
	Path string `yaml:"path"`
}

type RuntimePrefixes struct {
	Params  string // "params." or ""
	Types   string // "types." or ""
	Helpers string // "helpers." or ""
}

type SchemaContext int

type SchemaDescriptor struct {
	// Path is where this schema appears in the document
	Path SchemaPath

	// Ref is the $ref string if this is a reference (e.g., "#/components/schemas/Pet")
	// Empty if this is an inline schema definition
	Ref string

	// Schema is the underlying schema from libopenapi
	// nil for unresolved external references
	Schema *base.Schema

	// Parent points to the containing schema (nil for top-level schemas)
	Parent *SchemaDescriptor

	// StableName is the deterministic Go type name derived from the full path.
	// This name is stable across spec changes and should be used for type definitions.
	// Example: #/components/schemas/Cat -> CatSchemaComponent
	StableName string

	// ShortName is a friendly alias that may change due to deduplication.
	// Generated as a type alias pointing to StableName.
	ShortName string

	// OperationID is the operationId from the path operation, if this schema
	// comes from a path's request body or response. Used for friendlier naming.
	OperationID string

	// ContentType is the media type (e.g., "application/json") if this schema
	// comes from a request body or response content. Used for naming.
	ContentType string

	// Extensions holds parsed x- extension values for this schema.
	// These control code generation behavior (type overrides, field names, etc.)
	Extensions *Extensions

	// Discriminator holds discriminator info if this schema has oneOf/anyOf
	// with a discriminator. nil when no discriminator is present.
	Discriminator *DiscriminatorInfo

	// Recursive structure:
	Properties      map[string]*SchemaDescriptor
	Items           *SchemaDescriptor
	AllOf           []*SchemaDescriptor
	AnyOf           []*SchemaDescriptor
	OneOf           []*SchemaDescriptor
	AdditionalProps *SchemaDescriptor
}

type SchemaKind int

type SchemaPath []string

type SecurityRequirement struct {
	Name   string   // Security scheme name
	Scopes []string // Required scopes (for OAuth2)
}

type SenderTemplateData struct {
	IsClient    bool                   // true for client, false for initiator
	Prefix      string                 // "" for client, "Webhook"/"Callback" for initiator
	PrefixLower string                 // "" for client, "webhook"/"callback" for initiator
	TypeName    string                 // "Client" or "WebhookInitiator"
	Receiver    string                 // "c" or "p"
	OptionType  string                 // "ClientOption" or "WebhookInitiatorOption"
	ErrorType   string                 // "ClientHttpError" or "WebhookHttpError"
	SimpleType  string                 // "SimpleClient" or "SimpleWebhookInitiator"
	Operations  []*OperationDescriptor // Operations to generate for
}

type ServerGenerator struct {
	// contains filtered or unexported fields
}

type SimpleTypeSpec struct {
	Type     string `yaml:"type"`
	Import   string `yaml:"import,omitempty"`
	Template string `yaml:"template,omitempty"`
}

type StructField struct {
	Name            string // Go field name
	Type            string // Go type expression
	JSONName        string // Original JSON property name
	Required        bool   // Is this field required in the schema
	Nullable        bool   // Is this field nullable (type includes "null")
	Pointer         bool   // Should this be a pointer type
	OmitEmpty       bool   // Include omitempty in json tag
	OmitZero        bool   // Include omitzero in json tag (Go 1.24+)
	JSONIgnore      bool   // Use json:"-" tag to exclude from marshaling
	Doc             string // Field documentation
	Default         string // Go literal for default value (empty if no default)
	IsStruct        bool   // True if this field is a struct type (for recursive ApplyDefaults)
	IsExternal      bool   // True if this field references an external type (ApplyDefaults via reflection)
	IsNullableAlias bool   // True if type is a type alias to Nullable[T] (don't wrap or pointer)
	Order           *int   // Optional field ordering (lower values come first)
}

type StructTagGenerator struct {
	// contains filtered or unexported fields
}

type StructTagInfo struct {
	// FieldName is the JSON/YAML field name (from the OpenAPI property name)
	FieldName string
	// IsOptional is true if the field is optional (not required)
	IsOptional bool
}

type StructTagTemplate struct {
	// Name is the tag name (e.g., "json", "yaml", "form")
	Name string `yaml:"name"`
	// Template is a Go text/template that produces the tag value.
	// Available fields: .FieldName, .IsOptional
	// Example: `{{ .FieldName }}{{if .IsOptional}},omitempty{{end}}`
	Template string `yaml:"template"`
}

type StructTagsConfig struct {
	// Tags is the list of tags to generate for struct fields.
	// Order is preserved in the generated output.
	Tags []StructTagTemplate `yaml:"tags,omitempty"`
}

type TypeGenerator struct {
	// contains filtered or unexported fields
}

type TypeMapping struct {
	Integer FormatMapping `yaml:"integer,omitempty"`
	Number  FormatMapping `yaml:"number,omitempty"`
	Boolean FormatMapping `yaml:"boolean,omitempty"`
	String  FormatMapping `yaml:"string,omitempty"`
}

type TypeOverride struct {
	TypeName    string // The Go type name (e.g., "uuid.UUID")
	ImportPath  string // Import path (e.g., "github.com/google/uuid")
	ImportAlias string // Optional import alias (e.g., "foo" for `import foo "..."`)
}

type UnionMember struct {
	TypeName            string   // Go type name (e.g., "Cat")
	MethodName          string   // Suffix for As/From/Merge methods (e.g., "Cat")
	Index               int      // Position in anyOf/oneOf array
	HasApplyDefaults    bool     // Whether this type has an ApplyDefaults method
	DiscriminatorValues []string // Discriminator mapping keys for this variant (empty if unmapped)
}

type UnionTypeConfig struct {
	TypeName      string
	Members       []UnionMember
	IsOneOf       bool
	Doc           string
	FixedFields   []StructField
	Discriminator *DiscriminatorInfo
	TagGen        *StructTagGenerator
	HelperPrefix  string         // e.g., "oapiCodegenHelpersPkg." or "" for embedded
	Converter     *NameConverter // for converting JSON property names to Go field names
}