gomappergen

type BuiltInConverterConfig struct {
	UseIdentical       bool
	UseSlice           bool
	UseTypeToPointer   bool
	UsePointerToType   bool
	UseNumeric         bool
	UseFunctions       bool
	UseFunctionsStrict bool
}

type Config struct {
	BuiltInConverters   BuiltInConverterConfig
	LibraryConverters   LibraryConverterConfig
	ConverterFunctions  []ConvertFunctionConfig
	ConverterPriorities []string
	Packages            map[string][]PackageConfig
}

type ConfigMapper struct {
	Provider FieldInterceptorProvider
}

type ConvertFunctionConfig struct {
	PackagePath string
	TypeName    string
}

type Converter interface {
	// Init is called once before code generation starts.
	// It allows the converter to initialize internal state, validate assumptions,
	// or prepare data required during code generation. Init must not emit code.
	// If no initialization is required, the implementation may be a no-op.
	Init(parser Parser, config Config, logger *slog.Logger)

	// Info returns metadata describing the converter.
	Info() ConverterInfo

	// CanConvert reports whether this converter can convert a value of
	// sourceType into a value of targetType. Implementations typically use
	// TypeUtil to perform type analysis.
	//
	// CanConvert must be pure and must not modify file state.
	CanConvert(ctx LookupContext, targetType, sourceType types.Type) bool

	// ConvertField emits the assignment code that writes the converted value from
	// source into target. Returning nil suppresses emission.
	//
	// GeneratorUtil may be used to build complex expression trees.
	ConvertField(ctx ConverterContext, target, source Symbol) jen.Code
}

type ConverterContext interface {
	context.Context
	LookupContext

	// JenFile returns the current jennifer file used for code generation.
	// Converters may append generated code to this file.
	JenFile() *jen.File

	// Parser returns the type parser used to inspect and analyze Go types
	// during conversion.
	Parser() Parser

	// NextVarName returns a unique variable name for use in generated code.
	// It guarantees no name collisions within the current generation scope.
	NextVarName() string

	// Run executes runner if the context has not been cancelled.
	// If the context is done, Run returns nil and runner is not executed.
	// This allows converters to respect generator-defined timeouts without
	// explicitly checking ctx.Done().
	Run(converter Converter, runner func() jen.Code) jen.Code

	// EmitTraceComments indicates whether the converter should emit trace comments
	// for debugging or inspection purposes. It returns false by default.
	EmitTraceComments() bool
}

type ConverterInfo struct {
	Name                 string
	ShortForm            string
	ShortFormDescription string
}

type ConverterTestCase struct {
	Name                         string
	AdditionalCode               []string
	Config                       *Config
	Imports                      map[string]string
	GoModGoVersion               string
	GoModRequires                map[string]string
	GoModModule                  string
	TargetType                   string
	SourceType                   string
	EmitTraceComments            bool
	TargetSymbolWithoutFieldName bool
	SourceSymbolWithoutFieldName bool
	TargetSymbolMetadata         SymbolMetadata
	SourceSymbolMetadata         SymbolMetadata
	ExpectedCanConvert           bool
	ExpectedImports              []string
	ExpectedCode                 []string
	PrintSetUp                   bool
}

type DecoratorMode int

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

type FieldConfig struct {
	NameMatch NameMatch
	ManualMap map[string]string
}

type FieldInterceptor interface {
	GetType() string

	GetOptions() map[string]any

	Init(parser Parser, logger *slog.Logger)

	InterceptCanConvert(converter Converter, ctx LookupContext, targetType, sourceType types.Type) bool

	InterceptConvertField(converter Converter, ctx ConverterContext, target, source Symbol) jen.Code
}

type FieldInterceptorProvider interface {
	MakeFieldInterceptor(typ string, options map[string]any) FieldInterceptor
}

type FileManager interface {
	MakeJenFile(parser Parser, currentPkg *packages.Package, config PackageConfig) *jen.File

	JenFiles() map[string]*jen.File
}

type FuncInfo struct {
	Name        string
	PackagePath string
	Params      []types.Type
	Results     []types.Type
}

type GeneratedTypeOrchestrator struct {
	Generated TypeInfo
	Target    TypeInfo

	GeneratedToTarget        func(ctx ConverterContext, target, source Symbol) jen.Code
	GeneratedToTargetToOther func(ctx ConverterContext, target, source Symbol, targetToOther Converter) jen.Code
	TargetToGenerated        func(ctx ConverterContext, target, source Symbol) jen.Code
	OtherToTargetToGenerated func(ctx ConverterContext, target, source Symbol, otherToTarget Converter) jen.Code
	// contains filtered or unexported fields
}

type Generator interface {
	Generate(currentPkg *packages.Package, configs []PackageConfig) error
}

type GoldenTestCase struct {
	Name                     string
	GoModFileContent         []byte
	GoSumFileContent         []byte
	PklDevFileContent        []byte
	SourceFiles              map[string][]byte
	GoldenFiles              map[string][]byte
	PrintSetup               bool
	PrintActual              bool
	PrintDiff                bool
	FieldInterceptorProvider FieldInterceptorProvider
}

type GoldenTestCaseFromTestData struct {
	Name             string
	PkgPath          string
	GoModGoVersion   string
	GoModRequires    map[string]string
	GoModModule      string
	GoSumFileContent []byte
	SourceFiles      map[string]string
	PklFile          string
	GoldenFile       string
	OutputFileName   string
	PrintSetup       bool
	PrintActual      bool
	PrintDiff        bool
}

type GoldenTestCaseRunOptions struct {
	SetupConverter func()
}

type GoldenTestCaseRunOptionsFunc func(opts *GoldenTestCaseRunOptions)

type LibraryConverterConfig struct {
	UseGRPC   bool
	UsePGType bool
	UseSQL    bool
}

type LookupContext interface {
	// LookUp searches the global converter registry for a converter that
	// can convert a value of sourceType to targetType, excluding the provided
	// currentConverter (if non-nil).
	//
	// This helper is intended for converter implementations that need to
	// delegate or reuse existing conversion rules. A common use-case is a
	// SliceConverter that converts []T -> []V by looking up a converter for
	// T -> V and then generating per-element conversion code.
	//
	// Selection rules (implementation contract):
	//  1. The registry is scanned for converters c where c.CanConvert(targetType, sourceType)
	//     returns true.
	//  2. The currentConverter parameter is excluded from consideration to avoid
	//     trivial self-selection (if currentConverter == nil, no exclusion occurs).
	//  3. From the remaining candidates, the converter with the highest priority
	//     (your package's ordering rule: lower numeric value = higher priority)
	//     is chosen. If multiple converters share the same priority, the selection
	//     must be deterministic (for example: registration order or stable sorting).
	//
	// Return value:
	//   - (Converter, true) if a matching converter was found.
	//   - (nil, false) if no converter in the registry can perform the conversion.
	LookUp(current Converter, targetType, sourceType types.Type) (Converter, error)

	TargetDescriptor() *Descriptor

	SourceDescriptor() *Descriptor

	// Logger returns a slog handler that can be used for logging during
	// code generation.
	Logger() *slog.Logger
}

type MarkdownTestCase struct {
	Name              string
	Content           string
	Headers           []string
	SourceFiles       map[string][]byte
	GoldenFiles       map[string][]byte
	GoModFileContent  []byte
	GoSumFileContent  []byte
	PklDevFileContent []byte
}

type Mode int

type NameMatch int

type OptionFunc func(*Options)

type Options struct {
	Parser      Parser
	FileManager FileManager
	Logger      *slog.Logger
}

type Output struct {
	PkgName      string
	FileName     string
	TestFileName string
}

type PackageConfig struct {
	Mode                   Mode
	Output                 Output
	InterfaceName          string
	ImplementationName     string
	ConstructorName        string
	DecoratorInterfaceName string
	DecoratorNoOpName      string
	Structs                []StructConfig
	GenerateGoDoc          bool
}

type Parser interface {
	SourceDir() string

	SourcePackages() []*packages.Package

	FindStruct(pkgPath string, name string) (StructInfo, bool)

	FindFunction(pkgPath string, name string) (FuncInfo, bool)

	FindVariableMethods(pkgPath string, name string) []FuncInfo
}

type Pointer int

type StandardConversionOrchestrator struct {
	Source TypeInfo
	Target TypeInfo

	SourceToTarget               func(ctx ConverterContext, target, source Symbol) jen.Code
	OtherToSourceToTarget        func(ctx ConverterContext, target, source Symbol, otherToSource Converter) jen.Code
	SourceToTargetToOther        func(ctx ConverterContext, target, source Symbol, targetToOther Converter) jen.Code
	OtherToSourceToTargetToOther func(ctx ConverterContext, target, source Symbol, otherToSource, targetToOther Converter) jen.Code

	TargetToSource               func(ctx ConverterContext, target, source Symbol) jen.Code
	OtherToTargetToSource        func(ctx ConverterContext, target, source Symbol, otherToTarget Converter) jen.Code
	TargetToSourceToOther        func(ctx ConverterContext, target, source Symbol, sourceToOther Converter) jen.Code
	OtherToTargetToSourceToOther func(ctx ConverterContext, target, source Symbol, otherToTarget, sourceToOther Converter) jen.Code
}

type StructConfig struct {
	MapperName       string
	TargetPkgPath    string
	TargetStructName string
	SourcePkgPath    string
	SourceStructName string

	SourceToTargetFuncName   string
	SourceFromTargetFuncName string

	DecoratorMode    DecoratorMode
	DecorateFuncName string

	Pointer Pointer
	Fields  FieldConfig

	SourceFieldInterceptors map[string]FieldInterceptor
	TargetFieldInterceptors map[string]FieldInterceptor

	UseGetter bool

	GenerateSourceToTarget   bool
	GenerateSourceFromTarget bool
}

type StructFieldInfo struct {
	Name       string
	Getter     *string
	Tag        *string
	Comment    *string
	Doc        *string
	Type       types.Type
	Index      int
	IsExported bool
}

type StructInfo struct {
	Type   types.Type
	Fields map[string]StructFieldInfo
}

type Symbol struct {
	VarName   string
	FieldName *string
	Type      types.Type
	Metadata  SymbolMetadata
}

type SymbolMetadata struct {
	IsVariable   bool
	HasZeroValue bool
}

type TypeInfo struct {
	PkgPath   string
	PkgName   string
	TypeName  string
	IsPointer bool
}