mapper

type BuiltInConverter struct {
	EnableIdentical bool `pkl:"enable_identical"`

	EnableSlice bool `pkl:"enable_slice"`

	EnableTypeToPointer bool `pkl:"enable_type_to_pointer"`

	EnablePointerToType bool `pkl:"enable_pointer_to_type"`

	EnableNumeric bool `pkl:"enable_numeric"`

	EnableFunctions bool `pkl:"enable_functions"`

	EnableFunctionsStrict bool `pkl:"enable_functions_strict"`

	Library BuiltInLibraryConverter `pkl:"library"`
}

type BuiltInLibraryConverter struct {
	EnableGrpc bool `pkl:"enable_grpc"`

	EnablePgtype bool `pkl:"enable_pgtype"`

	EnableSql bool `pkl:"enable_sql"`
}

type Converter struct {
	BuiltIn BuiltInConverter `pkl:"built_in"`

	Functions *[]string `pkl:"functions"`

	Priorities []string `pkl:"priorities"`
}

type FieldInterceptor struct {
	Type string `pkl:"type"`

	Options map[string]any `pkl:"options"`
}

type Fields struct {
	Match string `pkl:"match"`

	Map *map[string]string `pkl:"map"`

	Target *map[string]FieldInterceptor `pkl:"target"`

	Source *map[string]FieldInterceptor `pkl:"source"`
}

type Mapper struct {
}

type Package interface {
	GetMode() string

	GetInterfaceName() string

	GetImplementationName() string

	GetConstructorName() string

	GetSourceToTargetFunctionName() string

	GetSourceFromTargetFunctionName() string

	GetDecoratorMode() decoratormode.DecoratorMode

	GetPointer() pointer.Pointer

	GetDecoratorInterfaceName() string

	GetDecoratorNoopName() string

	GetDecorateFunctionName() string

	GetTargetPkg() string

	GetSourcePkg() string

	GetStructs() map[string]Struct

	GetUseGetterIfAvailable() bool

	GetGenerateSourceToTarget() bool

	GetGenerateSourceFromTarget() bool

	GetGenerateGoDoc() bool
}

type PackageImpl struct {
	// Controls the overall generation strategy.
	//
	// - "types": Generates an interface, implementation struct, and constructor.
	// - "functions": Generates package-level mapping functions only (no interface or struct).
	//
	// Note: When mode = "functions", type-related naming options are ignored.
	Mode string `pkl:"mode"`

	// Name of the generated mapper interface.
	//
	// Used only when mode = "types".
	// Defaults to a non-exported name to avoid polluting consumer APIs.
	InterfaceName string `pkl:"interface_name"`

	// Name of the generated mapper implementation struct.
	//
	// Used only when mode = "types".
	ImplementationName string `pkl:"implementation_name"`

	// Name of the constructor function for the mapper implementation.
	//
	// Used only when mode = "types".
	ConstructorName string `pkl:"constructor_name"`

	// Default template for source-to-target mapping function names.
	// `{TargetStructName}` will be replaced with the actual target struct name.
	//
	// Can be overridden per struct.
	SourceToTargetFunctionName string `pkl:"source_to_target_function_name"`

	// Default template for target-to-source mapping function names.
	// `{TargetStructName}` will be replaced with the actual target struct name.
	//
	// Can be overridden per struct.
	SourceFromTargetFunctionName string `pkl:"source_from_target_function_name"`

	// Controls whether and how decorators are generated.
	//
	// - "adaptive": Generate decorators only when customization hooks are needed.
	// - "always": Always generate decorator types.
	// - "never": Never generate decorators.
	//
	// Can be overridden per struct.
	DecoratorMode decoratormode.DecoratorMode `pkl:"decorator_mode"`

	// Controls pointer usage in generated mapping code.
	//
	// - "none": Neither source nor target is treated as a pointer.
	// - "source-only": Source struct is passed as a pointer.
	// - "target-only": Target struct is returned or populated as a pointer.
	// - "both": Both source and target are pointers.
	//
	// Can be overridden per struct.
	Pointer pointer.Pointer `pkl:"pointer"`

	// Name of the generated decorator interface. Used only when decorator_mode != "never"
	//
	// Can be overridden per struct.
	DecoratorInterfaceName string `pkl:"decorator_interface_name"`

	// Name of the no-op decorator implementation. Empty string
	// would skip the NoOp implementation.
	//
	// Used only when decorator_mode != "never"
	DecoratorNoopName string `pkl:"decorator_noop_name"`

	// Template for the decorator function name.
	//
	// `{FunctionName}` will be replaced with the decorated function name.
	DecorateFunctionName string `pkl:"decorate_function_name"`

	// Default target package for generated mapper code.
	//
	// Defaults to the current package where generation is invoked.
	TargetPkg string `pkl:"target_pkg"`

	// Default source package containing input structs.
	//
	// Can be overridden per struct.
	SourcePkg string `pkl:"source_pkg"`

	// Mapping definitions for this package.
	//
	// Each entry describes how a source struct maps to a target struct.
	Structs map[string]Struct `pkl:"structs"`

	// Whether to prefer getter methods over direct field access
	// on source structs by default.
	//
	// Can be overridden per struct.
	UseGetterIfAvailable bool `pkl:"use_getter_if_available"`

	// Whether to generate source-to-target mapping code.
	// When false, only target-to-source mapping is generated.
	//
	// Can be overridden per struct.
	GenerateSourceToTarget bool `pkl:"generate_source_to_target"`

	// Whether to generate target-to-source mapping code.
	// When false, only source-to-target mapping is generated.
	//
	// Can be overridden per struct.
	GenerateSourceFromTarget bool `pkl:"generate_source_from_target"`

	// Whether to generate GoDoc comments for generated code.
	GenerateGoDoc bool `pkl:"generate_go_doc"`
}

type Struct struct {
	// Target package for the generated mapping code.
	//
	// Overrides package level target_pkg when set.
	TargetPkg *string `pkl:"target_pkg"`

	// Name of the target struct.
	//
	// If not set, the target struct name is inferred from context.
	TargetStructName *string `pkl:"target_struct_name"`

	// Source package containing the source struct.
	//
	// Overrides package level source_pkg when set.
	SourcePkg *string `pkl:"source_pkg"`

	// Name of the source struct.
	//
	// If not set, the source struct name is inferred from context.
	SourceStructName *string `pkl:"source_struct_name"`

	// Template for the source-to-target mapping function name.
	//
	// Overrides package level source_to_target_function_name when set.
	SourceToTargetFunctionName *string `pkl:"source_to_target_function_name"`

	// Template for the target-to-source mapping function name.
	//
	// Overrides package level source_from_target_function_name when set.
	SourceFromTargetFunctionName *string `pkl:"source_from_target_function_name"`

	// Template for the decorator function name.
	//
	// Overrides package level decorate_function_name when set.
	DecorateFunctionName *string `pkl:"decorate_function_name"`

	// Controls whether and how decorators are generated.
	//
	// - "adaptive": Generate decorators only when customization hooks are needed.
	// - "always": Always generate decorator types.
	// - "never": Never generate decorators.
	//
	// Overrides package level decorator_mode when set.
	DecoratorMode *decoratormode.DecoratorMode `pkl:"decorator_mode"`

	// Controls pointer usage in generated mapping code.
	//
	// - "none": Neither source nor target is treated as a pointer.
	// - "source-only": Source struct is passed as a pointer.
	// - "target-only": Target struct is returned or populated as a pointer.
	// - "both": Both source and target are pointers.
	//
	// Overrides package level pointer when set.
	Pointer *pointer.Pointer `pkl:"pointer"`

	// Field-level mapping configuration.
	//
	// Controls how fields are matched and transformed between
	// source and target structs.
	Fields Fields `pkl:"fields"`

	// Target's fields interceptors. This is a shortcut of fields { target }
	// the value in both settings will be merged, the fields { target } will
	// win if there is a duplication.
	TargetFields *map[string]FieldInterceptor `pkl:"target_fields"`

	// Source's fields interceptors. This is a shortcut of fields { source }
	// the value in both settings will be merged, the fields { source } will
	// win if there is a duplication.
	SourceFields *map[string]FieldInterceptor `pkl:"source_fields"`

	// Whether to prefer getter methods over direct field access
	// on the source struct.
	//
	// Overrides package level use_getter_if_available when set.
	UseGetterIfAvailable *bool `pkl:"use_getter_if_available"`

	// Whether to generate source-to-target mapping code.
	// When false, only target-to-source mapping is generated.
	//
	// Overrides package level generate_source_to_target when set.
	GenerateSourceToTarget *bool `pkl:"generate_source_to_target"`

	// Whether to generate target-to-source mapping code.
	// When false, only source-to-target mapping is generated.
	//
	// Overrides package level generate_source_from_target when set.
	GenerateSourceFromTarget *bool `pkl:"generate_source_from_target"`
}