generator

type BoolType struct {
	SingleValue
}

type Client struct {
	Imports []Import

	Operations []ClientOperation

	IsDecodeJSONFunc bool
}

type ClientHeader struct {
	Name      string
	FieldName string
	Required  bool
	Type      Formatter
}

type ClientOperation struct {
	*Operation

	RequestVarName string
	IsRequestBody  bool

	Headers []ClientHeader
}

type Components struct {
	HasComponent bool

	Imports Imports

	Schemas          []SchemaComponent
	Headers          []HeaderComponent
	RequestBodies    []RequestBodyComponent
	QueryParameters  []QueryParameterComponent
	HeaderParameters []HeaderParameterComponent
	PathParameters   []PathParameterComponent
	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"`
}

type CookieParameter struct {
	specification.CookieParameter
}

type CustomType struct {
	Multivalue
	Type   string
	Import string

	Base SchemaType
}

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

type FileHandler struct {
	Imports []Import

	Handlers []*Handler

	IsWriteJSONFunc bool
	IsCustomMaybe   bool
}

type FloatType struct {
	SingleValue
	BitSize int
}

type Formatter interface {
	RenderFormat(from string) (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     Client
	Components Components

	Router      Router
	FileHandler FileHandler
}

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 HandlerParameters struct {
	Query  []HandlerQueryParameter
	Path   []HandlerPathParameter
	Header []HandlerHeaderParameter
}

type HandlerPathParameter struct {
	HandlerParameter

	ParameterName string
	Parser        Parser
}

type HandlerQueryParameter struct {
	HandlerParameter

	ParameterName string
	Required      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 HeaderComponent struct {
	Name        string
	Description string
	Type        Render
}

type HeaderParameter struct {
	Name          string
	FieldName     string
	FieldTypeName string
	Type          SchemaType
	Required      bool
	// contains filtered or unexported fields
}

type HeaderParameterComponent struct {
	Name        string
	Description string
	Type        SchemaType
}

type Import string

type Imports []Import

type IntType struct {
	SingleValue
	BitSize int
}

type MapType struct {
	SingleValue
	Key   SchemaType
	Value SchemaType
}

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

type Multivalue struct{}

type Operation struct {
	*specification.Operation

	Name        OperationName
	Description string
	Summary     string

	PathBuilder []OperationPathElement

	APIHandlerFieldName string
	HandlerTypeName     string

	RequestTypeName  string
	ResponseTypeName string

	Params OperationParams

	Body struct {
		TypeName 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
}

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

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

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

type PathParameterComponent struct {
	Name        string
	Description string
	Type        SchemaType
}

type PathParameters []*PathParameter

type PathParserConstant struct {
	SingleValue
	Prefix   string
	FullPath string
}

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

type QueryParameter struct {
	Name      string
	FieldName string
	Required  bool
	Type      SchemaType
	// contains filtered or unexported fields
}

type QueryParameterComponent struct {
	Name            string
	Description     string
	Type            SchemaType
	IsStringsParser bool
	IsArray         bool
}

type QuotedRender string

type Ref[T any] struct {
	// Multivalue
	Ref        string
	SchemaType specification.Ref[T]
}

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       SchemaType
	Formatter    Formatter
	IsMultivalue 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

	Imports    Imports
	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
}

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

	CustomJSONMarshaler bool
	StructureType       StructureType
}

type SchemaType interface {
	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 Maybe[SchemaType]
}

type TData map[string]any