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

	// Pointer represents the pointer of this field (i.e `*`).
	Pointer string

	// Container represents the container that this field represents.
	//
	// A container (in the domain of field manipulation) refers to a
	// category of types which indicate that a field contains multiple fields.
	//
	// a "struct" collection contains subfields with any other type.
	// an "interface" collection contains `func` subfields.
	Container 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

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

type FieldOptions struct {
	// 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.
	Loadpath  string           // The filepath the loader file is located in.
	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.
}

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