generator

type BoolType struct {
	SingleValue
}

type ClientOperationHeaderTemplate struct {
	Name      string
	Required  bool
	FieldName string

	Type Formatter
}

type ClientOperationQueryTemplate struct {
	Name      string
	Required  bool
	FieldName string

	RenderFormatStrings func(to, from string, isNew bool) (string, error)
}

type ClientOperationTemplate struct {
	Name        OperationName
	Description string
	HTTPMethod  specification.HTTPMethod
	Method      specification.HTTPMethodTitle
	PathRaw     string

	PathParams []PathStringBuilder

	RequestTypeName  string
	ResponseTypeName string

	Queries []ClientOperationQueryTemplate
	Headers []ClientOperationHeaderTemplate

	IsRequestBody bool

	Responses       []ClientResponseTemplate
	DefaultResponse *ClientResponseTemplate
}

type ClientResponseHeaderTemplate struct {
	Key                string
	Required           bool
	SchemaParseStrings ParserFunc
	FieldName          string
}

type ClientResponseTemplate struct {
	Name             string
	StatusCode       string
	ComponentRefName string
	Headers          []ClientResponseHeaderTemplate
	ContentJSON      bool
}

type ClientTemplate struct {
	Operations []ClientOperationTemplate
}

type Components struct {
	Schemas       *MappedList[specification.Ref[specification.Schema], SchemaComponent]
	Headers       []HeaderComponent
	RequestBodies []RequestBodyComponent
	Responses     []ResponseComponent

	HasContentJSON bool
}

type Config struct {
	Maybe struct {
		Import string `yaml:"import"`
		Type   string `yaml:"type"`
	} `yaml:"maybe"`

	Cors struct {
		Enable bool `yaml:"enable"`
	} `yaml:"cors"`

	CustomTypes struct {
		Ignore bool `yaml:"ignore"`
	} `yaml:"customTypes"`
}

type CookieParameter struct {
	specification.CookieParameter
}

type CustomType struct {
	Type   string
	Import string

	BaseType SchemaType
}

type ErrorRender interface {
	Wrap(reason string, errVar string) string
	New(message string) string
}

type FloatType struct {
	SingleValue
	BitSize int
}

type Formatter interface {
	RenderFormat(from string) (string, error)
	RenderFormatStrings(to, from string, isNew bool) (string, error)
}

type FormatterFunc func(from string) (string, error)

type GenOption interface {
	// contains filtered or unexported methods
}

type Generator struct {
	Options GeneratorOptions

	Spec *specification.Spec

	Imports    Imports
	Operations []*Operation
	Paths      []*PathItem

	Client     ClientTemplate
	Components Components

	Router Router

	HandlersFile    HandlersFileTemplate
	Handlers        []*Handler
	IsWriteJSONFunc bool
}

type GeneratorOptions struct {
	DoNotEdit    bool
	PackageName  string
	BasePath     string
	SpecFilename string
	IsCors       bool
}

type GoFile struct {
	SkipDoNotEdit bool
	PackageName   string
	Imports       Imports
	Body          Render
}

type Handler struct {
	*Operation

	HandlerFuncName string
	BasePathPrefix  string

	CanParseError bool

	Parameters  HandlerParameters
	PathParsers []Parser

	DefaultResponse *HandlerResponse
	Responses       []HandlerResponse
}

type HandlerHeaderParameter struct {
	HandlerParameter

	ParameterName string
	Required      bool
	Parser        Parser
}

type HandlerParameter struct {
	FieldName    string
	FieldType    Render
	FieldComment string
}

type HandlerParameterHeaderTemplate struct {
	HandlerParameter HandlerParameterTemplate

	ParameterName string
	Required      bool
	Parser        Parser
}

type HandlerParameterPathTemplate struct {
	HandlerParameter HandlerParameterTemplate
}

type HandlerParameterQueryTemplate struct {
	HandlerParameter HandlerParameterTemplate
	ParameterName    string
	Required         bool
	IsOptional       bool

	ParseStrings func(to, from string, isNew bool, mkErr ErrorRender) (string, error)
}

type HandlerParameterTemplate struct {
	FieldName    string
	FieldComment string
	FieldType    Render
}

type HandlerParameters struct {
	Query  []HandlerQueryParameter
	Path   []HandlerPathParameter
	Header []HandlerHeaderParameter
}

type HandlerPathParameter struct {
	HandlerParameter

	ParameterName string
	Parser        Parser
}

type HandlerQueryParameter struct {
	HandlerParameter

	ParameterName string
	Required      bool
	IsOptional    bool
	Parser        Parser
}

type HandlerResponse struct {
	*Response

	Name string
	// PrivateName string
	HandlerName OperationName

	Status    string
	IsDefault bool

	UsedIn []ResponseUsedIn

	IsBody       bool
	BodyTypeName Render
	Body         Render
	BodyRenders  Renders
	ContentType  string

	Struct StructureType

	Args []ResponseArg
}

type HandlerResponseTemplate struct {
	Name        string
	Description string
	HandlerName OperationName

	Status    string
	IsDefault bool

	UsedIn []ResponseUsedIn

	IsBody       bool
	BodyTypeName Render
	Body         Render
	BodyRenders  Renders
	ContentType  string

	Struct StructureType

	Args    []ResponseArg
	Headers []ResponseHeader

	IsComponent bool
}

type HandlerTemplate struct {
	Name        OperationName
	Description string
	Summary     string

	HandlerFuncName string
	BasePathPrefix  string

	CanParseError bool

	ParametersQuery  []HandlerParameterQueryTemplate
	ParametersPath   []HandlerParameterPathTemplate
	ParametersHeader []HandlerParameterHeaderTemplate

	BodyTypeName Render
	BodyType     Render

	PathParsers []Parser

	Responses       []HandlerResponseTemplate
	DefaultResponse Maybe[HandlerResponseTemplate]
}

type HandlersFileTemplate struct {
	Handlers []HandlerTemplate

	IsWriteJSONFunc bool
	IsCustomMaybe   bool
}

type HeaderComponent struct {
	Name        string
	Description string
	Type        Render
}

type HeaderParameter struct {
	Name          string
	Description   string
	FieldName     string
	FieldTypeName string
	Type          SchemaType
	Required      bool
}

type Import string

type Imports []Import

type IntType struct {
	SingleValue
	BitSize int
}

type MapType struct {
	SingleValue
	Key   SchemaType
	Value SchemaType
}

type MappedList[I comparable, O any] struct {
	List []O
	// contains filtered or unexported fields
}

type Maybe[T any] struct {
	IsSet bool
	Value T
}

type Multivalue struct{}

type Operation struct {
	*specification.Operation

	Name        OperationName
	Description string
	Summary     string

	Path Path

	PathBuilder []OperationPathElement

	APIHandlerFieldName string
	HandlerTypeName     string

	RequestTypeName  string
	ResponseTypeName string

	Params OperationParams

	Body struct {
		TypeName Render
		Type     Render
	}

	DefaultResponse *ResponseCode
	Responses       []*ResponseCode
}

type OperationName string

type OperationParams struct {
	Query   specification.Map[*QueryParameter]
	Headers specification.Map[*HeaderParameter]
	Path    specification.Map[*PathParameter]
	Cookie  specification.Map[*CookieParameter]
}

type OperationPathElement struct {
	Raw   string
	Param Maybe[*PathParameter]
}

type OptionalType struct {
	V         SchemaType
	MaybeType string
}

type Parser interface {
	ParseString(to, from string, isNew bool, mkErr ErrorRender) (string, error)
	IsMultivalue() bool
	ParseStrings(to, from string, isNew bool, mkErr ErrorRender) (string, error)
}

type ParserFunc func(to, from string, isNew bool, mkErr ErrorRender) (string, error)

type Path struct {
	Raw        string
	Dirs       []*PathV
	Parameters specification.Map[*PathV]
}

type PathItem struct {
	*specification.PathItem
	Operations []*Operation
}

type PathParameter struct {
	Name          string
	FieldName     string
	FieldTypeName string
	Type          SchemaType
	Description   string
	// contains filtered or unexported fields
}

type PathParameters []*PathParameter

type PathParserConstant struct {
	SingleValue
	Prefix   string
	FullPath string
}

type PathParserVariable struct {
	SingleValue
	FieldName string
	Name      string
	Convert   Parser
}

type PathStringBuilder struct {
	Prefix string
	Param  *PathParameter
}

type PathV struct {
	V          string
	IsVariable bool
	Param      *PathParameter
}

type QueryParameter struct {
	Name        string
	Description string
	FieldName   string
	Required    bool
	Type        SchemaType
}

type QuotedRender string

type RefSchemaType struct {
	Name string
	Ref  *SchemaComponent
}

type Render interface {
	Render() (string, error)
}

type RenderFunc func() (string, error)

type Renders []Render

type RequestBodyComponent struct {
	Name        string
	Description string
	Type        Render
}

type Response struct {
	*specification.Response

	Name string

	Headers []ResponseHeader

	// Content specification.Map[specification.Ref[SchemaType]]
	ContentJSON Maybe[Schema]
}

type ResponseArg struct {
	FieldName string
	ArgName   string
	IsHeader  bool
	Type      Render
}

type ResponseCode struct {
	*Response
	StatusCode   string
	ComponentRef *specification.Object[string, specification.Ref[specification.Response]]
}

type ResponseComponent struct {
	Name        string
	Description string
	Alias       string
	IsComponent bool

	HandlerResponse
}

type ResponseHeader struct {
	Spec *specification.Header

	FieldName string
	Key       string
	Required  bool
	Schema    interface {
		Render
		Parser
	}
	IsCustomType bool
}

type ResponseUsedIn struct {
	OperationName OperationName
	Status        string
}

type Route struct {
	Name     string
	BasePath string
	Prefix   string

	PrefixPathItems []*RoutePathItem
	Variable        *RoutePathItem

	Routes []*Route

	VariableRoute *Route
	// contains filtered or unexported fields
}

type RoutePathItem struct {
	*RouterPathItem
	Prefix string
}

type Router struct {
	BasePath     string
	SpecFilename string
	SpecFileExt  string

	PathItems  []*RouterPathItem
	Operations []*Operation
	Routes     []*Route

	JWT  bool
	Cors bool
}

type RouterPathItem struct {
	RawPath string

	Operations []RouterPathItemOperation

	JWT        bool
	HasOptions bool
}

type RouterPathItemOperation struct {
	Name     OperationName
	Method   specification.HTTPMethodTitle
	PathSpec string
	Handler  string

	IsCORS      bool
	CORSMethods []string
	CORSHeaders []string
}

type Schema struct {
	Spec specification.Ref[specification.Schema]
	Type SchemaType
}

type SchemaComponent struct {
	Name              string
	Description       string
	Type              SchemaType
	IgnoreParseFormat bool
	IsMultivalue      bool
	IsAlias           bool

	RenderFormatStringsMultiline func(to, from string) (string, error)

	CustomJSONMarshaler bool
	StructureType       StructureType

	Ref Maybe[*SchemaComponent]

	BaseType Render
	IsRef    bool
}

type SchemaType interface {
	Base() SchemaType

	Render
	Parser
	Formatter
}

type SingleValue struct{}

type SliceType struct {
	Multivalue
	Items SchemaType
}

type StringRender string

type StringType struct {
	SingleValue
}

type StructureField struct {
	Comment string
	Name    string
	Type    Render
	Tags    []StructureFieldTag
	JSONTag string
}

type StructureFieldTag struct {
	Key    string
	Values []string
}

type StructureType struct {
	SingleValue
	Fields []StructureField

	AdditionalProperties *SchemaType
}

type TData map[string]any