models

type Field struct {
	// VariableName represents name that is used to assign the field.
	//
	// This value will always be unique in the context of the application.
	// TypeField variable names do not contain '.' (i.e 'tA' in 'tA.UserID').
	// Field variable names are defined by their specifier (i.e '.UserID' in 'domain.Account.UserID').
	VariableName string

	// Import represents the file that field was imported from.
	Import string

	// Package represents the package the field is defined in (i.e `log` in `log.Logger`).
	Package string

	// Name represents the name of the field (i.e `ID` in `ID int`).
	Name string

	// Definition represents the type definition of the field (i.e `int` in `ID int`, `Logger` in `log.Logger`).
	Definition string

	// The tags defined in a struct field (i.e `json:"tag,omitempty"`)
	// map[tag]map[name][]options (i.e map[json]map[tag]["omitempty"])
	Tags map[string]map[string][]string

	// The type or field that contains this field.
	Parent *Field

	// Underlying represents the underlying type field of this field (or nil).
	// The underlying field of a `type Number string` *Field is a `string` *Field.
	//
	// Underlying fields of the same type point to the same *Field object.
	Underlying *Field

	// The field that this field will be copied from (or nil).
	//
	// Set in the matcher.
	From *Field

	// The field that this field will be copied to (or nil).
	//
	// Set in the matcher.
	To *Field

	// The fields of this field.
	Fields []*Field

	// The custom options of a field.
	Options FieldOptions

	// Embedded represents whether the field is an embedded field.
	Embedded bool
}

type FieldOptions struct {
	// The function the field is casted with.
	Cast string

	// The function the field is converted with (as a parameter).
	Convert string

	// The field to map this field to, if any.
	Map string

	// The tag to map this field with, if any.
	Tag string

	// The level at which sub-fields are discovered.
	Depth int

	// Whether the field should be explicitly automatched.
	Automatch bool

	// Whether the field should be deepcopied.
	Deepcopy bool
}

type Function struct {
	Name    string          // The name of the function.
	Options FunctionOptions // The custom options of a function.
	From    []Type          // The types to copy fields from.
	To      []Type          // The types to copy fields to.
}

type FunctionOptions struct {
	Custom map[string][]string // The custom options of a function (map[option]values).
	Manual bool                // Whether the function uses a manual matcher (as opposed to an Automatcher).
}

type Generator struct {
	Functions []Function       // The functions to generate.
	Options   GeneratorOptions // The custom options for the generator.
	Setpath   string           // The filepath the setup file is located in.
	Outpath   string           // The filepath the generated code is output to.
	Tempath   string           // The filepath for the template used to generate code.
	Keep      []byte           // The code that is kept from the setup file.
}

type GeneratorOptions struct {
	Custom  map[string]interface{} // The custom options of a generator.
	Matcher MatcherOptions         // The options for the matcher of a generator.
}

type MatcherOptions struct {
	CastDepth                    int  // The option that sets the maximum depth for automatic casting.
	Skip                         bool // The option that skips the matcher.
	AutoCast                     bool // The option that enables automatic casting.
	DisableAssignObjectInterface bool // The cast option feature flag that disables assignment of objects to interfaces.
	DisableAssertInterfaceObject bool // The cast option feature flag that disables assignment of interfaces to objects.
	DisableConvert               bool // The cast option feature flag that disables type conversion.
}

type Type struct {
	// Field represents field information for the type.
	Field *Field
}