generator

type AssignData struct {
	From, To Templater
	IsNew    bool
}

type BoolType struct{}

type Client struct {
	Imports []Import

	Operations []ClientOperation

	IsDecodeJSONFunc bool
}

type ClientHeader struct {
	Name      string
	FieldName string
	Required  bool
}

type ClientOperation struct {
	*Operation

	RequestVarName string
	IsRequestBody  bool

	Headers []ClientHeader
}

type Components struct {
	Imports Imports

	Schemas []SchemaComponent
}

type CookieParameter struct {
	specification.CookieParameter
}

type CustomType string

type ErrorRender interface {
	Wrap(message string) string
	New(message string) string
}

type ExecTemplater interface {
	Execute() (string, error)
}

type FloatType struct {
	BitSize int
}

type Formatter interface {
	RenderFormat(from Render) (string, error)
}

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

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

type Generator struct {
	Options GeneratorOptions

	Spec *specification.Spec

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

	Router Router
	Client Client
}

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

type GoFile struct {
	SkipDoNotEdit bool
	PackageName   string
	Imports       []Import
	Body          any
}

type Handler struct {
	Imports Imports

	Name       OperationName
	Method     specification.HTTPMethodTitle
	HTTPMethod specification.HTTPMethod
	Path       specification.PathOld2

	PathBuilder []PathDir

	HandlerTypeName      string
	HandlerInputTypeName string
	RequestTypeName      string
	RequestVarName       string

	Params struct {
		Query   []*QueryParameter
		Path    PathParameters
		Headers []*HeaderParameter
	}

	IsRequestBody bool

	ResponseTypeName        string
	ResponsePrivateFuncName string

	DefaultResponse Optional[*Response]
	Responses       []*Response
	// contains filtered or unexported fields
}

type HandlerOld struct {

	// deprecated
	Name        OperationName
	Description string
	Summary     string

	BasePathPrefix string

	CanParseError bool

	ResponserInterfaceName string

	IsJWT bool

	Parameters struct {
		Query   []Param
		Path    []Param
		Headers []Param

		PathParsers []Templater
	}

	Body struct {
		TypeName Templater
	}

	IsWriteJSONFunc bool

	Responses []Templater
}

type HandlersFile struct {
	Handlers []HandlerOld

	IsWriteJSONFunc bool
}

type Header struct {
	Spec specification.HeaderOld

	FieldName string
	Key       string
}

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

type Import string

type Imports []Import

type IntType struct {
	BitSize int
}

type Operation struct {
	*specification.Operation

	Name OperationName
	Path specification.PathOld2

	APIHandlerFieldName string
	HandlerTypeName     string

	RequestTypeName  string
	ResponseTypeName string

	Params OperationParams

	DefaultResponse Optional[*Response]
	Responses       []*Response
}

type OperationName string

type OperationOld struct {
	Operation *specification.Operation

	Name            OperationName
	HandlerTypeName string

	PathParameters   []Parameter[*specification.PathParameter]
	QueryParameters  []Parameter[*specification.QueryParameter]
	HeaderParameters []Parameter[*specification.HeaderParameter]

	Handler *HandlerOld // Deprecated
}

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

type Optional[T any] struct {
	Value T
	OK    bool
}

type Param struct {
	Field  Templater
	Parser Templater
}

type Parameter[T interface {
	*specification.PathParameter | *specification.QueryParameter | *specification.HeaderParameter
}] struct {
	Spec T

	FieldName string
}

type Parser interface {
	RenderParser(from, to Render, mkErr ErrorRender) (string, error)
}

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

type PathDir struct {
	V     string
	Param *PathParameter
}

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

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

type PathParameters []*PathParameter

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

type QuotedRender string

type RawTemplate string

type Ref string

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

type RenderFunc func() (string, error)

type Renders []Render

type Response struct {
	Name       string
	StatusCode string

	Headers []Header

	Body Optional[any]
	// contains filtered or unexported fields
}

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
}

type RouterPathItem struct {
	*PathItem

	JWT bool
}

type SchemaComponent struct {
	Name string
	Type Render
}

type SliceType struct {
	Items Render
}

type StringRender string

type StringType struct{}

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

type StructureFieldTag struct {
	Key    string
	Values []string
}

type StructureType struct {
	Fields []StructureField
}

type TData map[string]any

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

type Templater interface {
	// Execute() (string, error)
	String() (string, error)
}

type TemplaterFunc func() (string, error)

type Templaters []Templater