core

type Capabilities struct {
	SupportsClient     bool     // Can generate client code
	SupportsServer     bool     // Can generate server code
	SupportsValidation bool     // Can generate validators
	SupportsAsync      bool     // Supports async/await patterns
	SupportsStreaming  bool     // Supports streaming (SSE, Websockets)
	ClientFrameworks   []string // Supported client frameworks
	ServerFrameworks   []string // Supported server frameworks
}

type Config struct {

	// Source
	SpecPath string

	// Output
	OutputDir string

	// Generator selection
	Generator string

	// What to generate
	Generate GenerateConfig

	// Generator-specific options
	Options map[string]interface{}

	// Template customization
	Templates TemplateConfig

	// Exclusions
	Exclude ExcludeConfig

	// Custom type mappings
	Types TypesConfig
}

type Contact struct {
	Name  string
	Email string
	URL   string
}

type Discriminator struct {
	PropertyName string
	Mapping      map[string]string
}

type Encoding struct {
	ContentType string // e.g., "application/json" or "image/png"

}

type Endpoint struct {
	Path        string
	Method      string // GET, POST, PUT, DELETE, etc.
	OperationID string
	Summary     string
	Description string
	Tags        []string

	Parameters  []Parameter
	RequestBody *RequestBody
	Responses   []Response

	Security     []SecurityRequirement
	IsPublic     bool // true when security: [] is set explicitly (no auth required)
	IsDeprecated bool
}

type ErrorSeverity int

type ExcludeConfig struct {
	Models []string // model names to skip (exact match)
	Tags   []string // operation tags to skip
}

type Feature string

type GenerateConfig struct {
	Models, Client, Server, Validation bool
}

type GeneratedFile struct {
	Path     string                 // Relative path from output dir
	Content  []byte                 // File content
	Metadata map[string]interface{} // Optional metadata
}

type GenerationError struct {
	Severity ErrorSeverity
	Phase    string // "parsing", "validation", "generation"
	Location *Location
	Message  string
	Hint     string // Suggestion to fix
	Code     string // Error code (e.g., "E1001")
}

type GenerationResult struct {
	Files    []GeneratedFile
	Warnings []GenerationError
}

type Generator interface {

	// Metadata returs informatio about this generator
	Metadata() GeneratorMetadata

	// Validate checks if the spec and config are valid for this generator
	// Returns validation errors (does not stop on first error)
	Validate(spec *Spec, config *Config) []ValidationError

	// Generate produces code from the spec
	Generate(spec *Spec, config *Config) (*GenerationResult, error)

	// SupportedFeatures returns OpenAPI features this generator supports
	SupportedFeatures() []Feature
}

type GeneratorMetadata struct {
	Name         string       // Unique identifier (e.g., "go-generator")
	Language     string       // Target language (e.g., "go", "typescript")
	Version      string       // Semantic version
	Description  string       // Human-readable description
	Author       string       // Author/maintainer
	Capabilities Capabilities // What this generator can produce
}

type Header struct {
	Description string
	Required    bool
	Schema      *Property
}

type License struct {
	Name string
	URL  string
}

type Location struct {
	File   string // Spec file or template file
	Line   int
	Column int
	Path   string // JSON path (e.g., "#/paths/users/get")
}

type MediaType struct {
	Schema   *Property
	Example  interface{}
	Encoding map[string]Encoding // Mapping for multipart/form-data properties
}

type Model struct {
	Name        string
	Description string
	Type        string // "object", "array", "string", etc.
	Properties  []Property
	Required    []string
	Enum        []interface{}

	// For array type schemas
	IsArray bool      // true if this is an array schema
	Items   *Property // full items definition

	// For map type schemas (additionalProperties)
	IsMap           bool      // true if this is a map schema
	AdditionalProps *Property // the type of map values

	// Complex type handling
	AllOf []Model
	OneOf []Model
	AnyOf []Model

	// Metadata
	Discriminator *Discriminator
	IsDeprecated  bool
	Example       interface{}

	// Union type flags
	IsOneOf bool
	IsAnyOf bool

	// Source location
	SourcePath string // JSON Path in spec
}

type OAuthFlow struct {
	AuthorizationURL string
	TokenURL         string
	RefreshURL       string
	Scopes           map[string]string
}

type OAuthFlows struct {
	Implicit          *OAuthFlow
	Password          *OAuthFlow
	ClientCredentials *OAuthFlow
	AuthorizationCode *OAuthFlow
}

type Parameter struct {
	Name         string
	In           string // "path", "query", "header", "cookie"
	Description  string
	Required     bool
	Schema       *Property
	Example      interface{}
	IsDeprecated bool
}

type Property struct {
	Name        string
	Type        string
	Format      string
	Description string
	Required    bool
	Nullable    bool
	Enum        []interface{} // Enum values if this is an enum

	// Field metadata
	Default    interface{} // Default value
	ReadOnly   bool        // Read-only field
	WriteOnly  bool        // Write-only field
	Deprecated bool        // Deprecated field

	// Constraints
	Pattern     string
	MinLength   *int
	MaxLength   *int
	Minimum     *float64
	Maximum     *float64
	MinItems    *int
	MaxItems    *int
	UniqueItems bool
	MultipleOf  *float64

	// For nested types
	RefType string // Referenced type name (for $ref or nested objects)
	Items   *Property

	// For objects
	Properties []Property

	// Additional properties for maps
	AdditionalProperties *Property

	Example interface{}
}

type RefResolver struct {
}

type RequestBody struct {
	Description string
	Required    bool
	Content     map[string]MediaType // media type -> schema
}

type Response struct {
	StatusCode  string // "200", "404", "default"
	Description string
	Headers     map[string]Header
	Content     map[string]MediaType
}

type SecurityRequirement struct {
	Name   string
	Scopes []string
}

type SecurityScheme struct {
	Type             string // "apiKey", "http", "oauth2", "openIdConnect"
	Description      string
	Name             string // Scheme identifier (map key from spec, e.g. "bearerAuth")
	ParameterName    string // For apiKey: header/query/cookie parameter name (e.g. "X-API-Key")
	In               string // For apiKey: "header", "query", "cookie"
	Scheme           string // For http: "bearer", "basic", etc.
	BearerFormat     string // For http bearer
	Flows            *OAuthFlows
	OpenIDConnectURL string
}

type Spec struct {
	Raw *openapi3.T

	Info        SpecInfo
	Models      []Model
	Endpoints   []Endpoint
	Tags        []Tag
	SecurityDef []SecurityScheme

	Version string // OpenAPI Version (e.g., "3.0.0")
	// contains filtered or unexported fields
}

type SpecInfo struct {
	Title       string
	Description string
	Version     string
	Contact     *Contact
	License     *License
}

type Tag struct {
	Name        string
	Description string
}

type TemplateConfig struct {
	CustomDir string            // Path to custom templates directory (supplements built-ins)
	Overrides map[string]string // template name → file path (replaces individual templates)
}

type TypeOverride struct {
	Format string // OpenAPI format (e.g. "email", "uuid", "date-time")
	Type   string // OpenAPI type (e.g. "integer") — matched when Format is ""
	Go     string // Target Go type (e.g. "uuid.UUID", "EmailAddress")
}

type TypesConfig struct {
	Overrides []TypeOverride
}

type ValidationError struct {
	GenerationError
}