tqlgen

type Annotation struct {
	Key         bool         `parser:"  @'@key'"`
	Unique      bool         `parser:"| @'@unique'"`
	Abstract    bool         `parser:"| @'@abstract'"`
	Cascade     bool         `parser:"| @'@cascade'"`
	Independent bool         `parser:"| @'@independent'"`
	Distinct    bool         `parser:"| @'@distinct'"`
	Card        *CardAnnot   `parser:"| @@"`
	Regex       *RegexAnnot  `parser:"| @@"`
	Values      *ValuesAnnot `parser:"| @@"`
	Range       *RangeAnnot  `parser:"| @@"`
	Subkey      *SubkeyAnnot `parser:"| @@"`
	Doc         *DocAnnot    `parser:"| @@"`
	Meta        *MetaAnnot   `parser:"| @@"`
}

type AsClause struct {
	Parent string `parser:"'as' @Ident"`
}

type AttrDef struct {
	Name      string       `parser:"'attribute' @Ident"`
	Parent    *SubClause   `parser:"@@?"`
	PreAnnots []Annotation `parser:"@@*"`
	Comma     string       `parser:"','?"`
	ValueType string       `parser:"('value' @Ident)?"`
	Annots    []Annotation `parser:"@@*"`
	Semi      string       `parser:"';'"`
}

type AttributeSpec struct {
	// Name is the name of the attribute type.
	Name string
	// ValueType is the base value type of the attribute (string, integer, double, boolean, datetime).
	ValueType string
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec

	// Regex is an optional regular expression constraint for the attribute values.
	Regex string
	// Values is an optional list of allowed values (enumeration constraint).
	Values []string
	// RangeOp is an optional range constraint (e.g., "1..5").
	RangeOp string

	// Parent is the parent attribute type name when the attribute is declared
	// with `sub` (attribute subtyping). Empty for root attributes.
	Parent string
	// Abstract indicates whether the attribute type is declared @abstract.
	Abstract bool
}

type BaseStructConfig struct {
	// SourceEntity is the schema entity name that triggers this base struct.
	SourceEntity string
	// BaseName is the Go struct name prefix (e.g., "BaseArtifact").
	BaseName string
	// InheritedAttrs lists attribute names defined in the base struct.
	// These are skipped when rendering child entity DTOs.
	InheritedAttrs []string
	// ExtraFields adds additional fields as name → Go type annotation.
	ExtraFields map[string]string
}

type CardAnnot struct {
	Expr string `parser:"'@card' '(' @CardExpr ')'"`
}

type CompositeEntityConfig struct {
	// Name is the Go struct name for the composite DTO (e.g., "ArtifactDTO").
	Name string
	// Entities lists the TypeDB entity names to merge.
	Entities []string
	// TypeName is the TypeDB type name for TypeName() method (e.g., "artifact").
	TypeName string
}

type DTOConfig struct {
	// PackageName is the Go package name for the generated file (required).
	PackageName string
	// UseAcronyms applies Go acronym naming conventions (e.g., "ID" not "Id").
	UseAcronyms bool
	// SkipAbstract excludes abstract types from DTO generation.
	SkipAbstract bool
	// IDFieldName is the name of the ID field in Out structs (default "ID").
	IDFieldName string
	// StrictOut makes required fields non-pointer in Out structs.
	// When false (default), all attribute fields in Out are pointers for safety.
	StrictOut bool
	// ExcludeEntities lists entity names to skip during generation.
	ExcludeEntities []string
	// ExcludeRelations lists relation names to skip during generation.
	ExcludeRelations []string
	// SkipRelationOut skips generating Out structs for relations.
	SkipRelationOut bool
	// BaseStructs configures shared base structs for entity hierarchies.
	BaseStructs []BaseStructConfig
	// EntityFieldOverrides provides per-entity, per-variant field overrides.
	EntityFieldOverrides []EntityFieldOverride
	// CompositeEntities configures merged flat structs from multiple entity types.
	CompositeEntities []CompositeEntityConfig
	// EntityOutName overrides the interface name for entity Out DTOs (default "EntityOut").
	EntityOutName string
	// EntityCreateName overrides the interface name for entity Create DTOs (default "EntityCreate").
	EntityCreateName string
	// EntityPatchName overrides the interface name for entity Patch DTOs (default "EntityPatch").
	EntityPatchName string
	// RelationOutName overrides the interface name for relation Out DTOs (default "RelationOut").
	RelationOutName string
	// RelationCreateName overrides the interface name for relation Create DTOs (default "RelationCreate").
	RelationCreateName string
	// RelationCreateEmbed is a struct name to embed in all relation Create DTOs.
	RelationCreateEmbed string
}

type DTOData struct {
	PackageName string
	NeedsTime   bool
	IDFieldName string

	// Base structs (from BaseStructConfig)
	BaseStructs []baseStructDTOCtx

	// Value structs generated from TypeQL struct definitions. Structs are
	// value types, so a single plain Go struct is emitted per TypeQL struct
	// (no Out/Create/Patch triple).
	Structs []structDTOCtx

	// Entity DTOs
	Entities []entityDTOCtx

	// Relation DTOs
	Relations           []relationDTOCtx
	SkipRelationOut     bool
	RelationCreateEmbed string

	// Composite entity DTOs
	Composites []compositeDTOCtx

	// Union interface lists (concrete types only)
	ConcreteEntities  []string // Go type names
	ConcreteRelations []string

	// Configurable interface names
	EntityOutName      string
	EntityCreateName   string
	EntityPatchName    string
	RelationOutName    string
	RelationCreateName string
}

type DocAnnot struct {
	Text string `parser:"'@doc' '(' @String ')'"`
}

type EntityClause struct {
	Owns  *OwnsDef   `parser:"  @@"`
	Plays *PlaysDef  `parser:"| @@"`
	Sub   *SubClause `parser:"| @@"`
}

type EntityDef struct {
	Name    string         `parser:"'entity' @Ident"`
	Parent  *SubClause     `parser:"@@?"`
	Annots  []Annotation   `parser:"@@*"`
	Comma   string         `parser:"','?"`
	Clauses []EntityClause `parser:"( @@ ( ',' @@ )* )? ';'"`
}

type EntityFieldOverride struct {
	// Entity is the TypeDB entity name.
	Entity string
	// Field is the TypeDB attribute name.
	Field string
	// Variant is the DTO variant: "out", "create", or "patch".
	Variant string
	// Required overrides whether the field is required (non-pointer).
	// nil means keep the schema default.
	Required *bool
}

type EntitySpec struct {
	// Name is the name of the entity type.
	Name string
	// Parent is the name of the parent entity type if this is a subtype.
	Parent string
	// Abstract indicates whether the entity type is defined as abstract.
	Abstract bool
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec

	// Owns is a list of attributes owned by this entity type.
	Owns []OwnsSpec
	// Plays is a list of relation roles this entity type can play.
	Plays []PlaysSpec
}

type EnumCtx = enumCtx

type EnumValueCtx = enumValueCtx

type FunBodyTok struct {
	Tok string `` /* 141-byte string literal not displayed */
}

type FunDef struct {
	Name string       `parser:"'fun' @Ident"`
	Body []FunBodyTok `parser:"@@*"`
}

type FunctionSpec struct {
	// Name is the name of the function.
	Name string
	// Parameters is a list of parameters accepted by the function.
	Parameters []ParameterSpec
	// ReturnType is the TypeQL return type of the function.
	ReturnType string
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
}

type JSONSchemaCtx struct {
	TypeName   string
	Properties []JSONSchemaPropCtx
	Required   []string
}

type JSONSchemaPropCtx struct {
	Name     string
	JSONType string
}

type KVCtx struct {
	Key, Value string
}

type KVMapCtx struct {
	Key    string
	Values []KVCtx
}

type KVSliceCtx struct {
	Key    string
	Values []string
}

type LeafConstantsConfig struct {
	// PackageName for the generated file (e.g. "schema").
	PackageName string
	// UseAcronyms applies Go acronym naming conventions.
	UseAcronyms bool
	// SkipAbstract excludes abstract types.
	SkipAbstract bool
}

type MetaAnnot struct {
	Key   string `parser:"'@meta' '(' @String ','"`
	Value string `parser:"@String ')'"`
}

type MetaSpec struct {
	// Key is the metadata key.
	Key string
	// Value is the metadata value.
	Value string
}

type OwnsDef struct {
	Attribute string       `parser:"'owns' @Ident"`
	IsList    bool         `parser:"( @'[' ']' )?"`
	Annots    []Annotation `parser:"@@*"`
}

type OwnsSpec struct {
	// Attribute is the name of the attribute type being owned.
	Attribute string
	// Key indicates whether this attribute is a key for the owner.
	Key bool
	// Unique indicates whether the attribute value must be unique across all instances.
	Unique bool
	// Card specifies the cardinality of the ownership (e.g., "0..1", "1..5").
	Card string
	// IsList indicates a TypeQL 3.x ordered-list ownership (owns attr[]).
	IsList bool
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
}

type ParameterSpec struct {
	// Name is the name of the parameter (without the '$' prefix).
	Name string
	// TypeName is the TypeQL type name expected for this parameter.
	TypeName string
}

type ParsedSchema struct {
	// Attributes is a list of all attribute definitions in the schema.
	Attributes []AttributeSpec
	// Entities is a list of all entity definitions in the schema.
	Entities []EntitySpec
	// Relations is a list of all relation definitions in the schema.
	Relations []RelationSpec
	// Functions is a list of all function signatures in the schema.
	Functions []FunctionSpec
	// Structs is a list of all struct definitions in the schema.
	Structs []StructSpec
}

type PlaysDef struct {
	Relation string       `parser:"'plays' @Ident"`
	Role     string       `parser:"':' @Ident"`
	Annots   []Annotation `parser:"@@*"`
}

type PlaysSpec struct {
	// Relation is the name of the relation type.
	Relation string
	// Role is the name of the role played by the owner within that relation.
	Role string
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
}

type RangeAnnot struct {
	Toks []RangeTok `parser:"'@range' '(' @@+ ')'"`
}

type RangeTok struct {
	Tok string `parser:"(?! ')' ) @(Ident | Punct | String | CardExpr | Var | Operator)"`
}

type RegexAnnot struct {
	Pattern string `parser:"'@regex' '(' @String ')'"`
}

type RegistryConfig struct {
	// PackageName is the Go package name for the generated code (required).
	PackageName string
	// UseAcronyms applies Go acronym naming conventions (e.g., "ID" not "Id").
	UseAcronyms bool
	// SkipAbstract excludes abstract types from entity/relation constants and EntityAttributes.
	SkipAbstract bool
	// Enums generates string constants from @values constraints.
	Enums bool
	// TypePrefix is the prefix for entity type constants (default "Type").
	TypePrefix string
	// RelPrefix is the prefix for relation type constants (default "Rel").
	RelPrefix string
	// SchemaText is the raw schema source. If non-empty, a SHA256-based SchemaHash is computed
	// and annotations are extracted from comments.
	SchemaText string
	// SchemaVersion is a user-provided version string emitted as a constant.
	SchemaVersion string
	// TypedConstants generates typed string constants (type EntityType string, etc.)
	// for compile-time safety instead of plain string constants.
	TypedConstants bool
	// JSONSchema generates JSON schema fragment maps for each entity/relation type.
	JSONSchema bool
}

type RegistryData struct {
	PackageName       string
	EntityConstants   []TypeConstCtx
	RelationConstants []TypeConstCtx
	Enums             []EnumCtx
	EntityParents     []KVCtx
	EntityAttributes  []KVSliceCtx
	AttrValueTypes    []KVCtx
	AttrEnumValues    []KVSliceCtx
	AttrRegex         []KVCtx
	AttrRange         []KVCtx
	RelationSchema    []RelSchemaCtx
	RelationAttrs     []KVSliceCtx
	AllEntityTypes    []string
	AllRelationTypes  []string
	// Metadata fields
	EntityKeys       []KVSliceCtx
	EntityAbstract   []string
	RelationAbstract []string
	RelationParents  []KVCtx
	SchemaHash       string
	SchemaVersion    string
	AttributeTypes   []string

	// Annotations from schema comments (# @key value)
	EntityAnnotations    []KVMapCtx
	AttributeAnnotations []KVMapCtx
	RelationAnnotations  []KVMapCtx

	// Typed constants (StrEnum-style)
	TypedConstants         bool
	AttributeTypeConstants []TypeConstCtx

	// JSON schema fragments
	JSONSchema       bool
	EntityJSONSchema []JSONSchemaCtx
	// StructJSONSchema carries one property map per TypeQL struct definition;
	// struct-valued fields (and struct-valued attributes in EntityJSONSchema)
	// map to the JSON type "object".
	StructJSONSchema []JSONSchemaCtx
}

type RelSchemaCtx struct {
	Name  string
	Roles []RoleCtx
}

type RelatesDef struct {
	Role     string       `parser:"'relates' @Ident"`
	IsList   bool         `parser:"( @'[' ']' )?"`
	AsParent *AsClause    `parser:"@@?"`
	Annots   []Annotation `parser:"@@*"`
}

type RelatesSpec struct {
	// Role is the name of the role in the relation.
	Role string
	// AsParent specifies an overridden role from a parent relation type.
	AsParent string
	// Card specifies the cardinality of players allowed for this role.
	Card string
	// IsList indicates a TypeQL 3.x ordered-list role (relates role[]).
	IsList bool
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
}

type RelationClause struct {
	Relates *RelatesDef `parser:"  @@"`
	Owns    *OwnsDef    `parser:"| @@"`
	Plays   *PlaysDef   `parser:"| @@"`
	Sub     *SubClause  `parser:"| @@"`
}

type RelationDef struct {
	Name    string           `parser:"'relation' @Ident"`
	Parent  *SubClause       `parser:"@@?"`
	Annots  []Annotation     `parser:"@@*"`
	Comma   string           `parser:"','?"`
	Clauses []RelationClause `parser:"( @@ ( ',' @@ )* )? ';'"`
}

type RelationSpec struct {
	// Name is the name of the relation type.
	Name string
	// Parent is the name of the parent relation type if this is a subtype.
	Parent string
	// Abstract indicates whether the relation type is defined as abstract.
	Abstract bool
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec

	// Relates is a list of roles involved in this relation.
	Relates []RelatesSpec
	// Owns is a list of attributes owned by this relation type.
	Owns []OwnsSpec
	// Plays is a list of relation roles this relation type can play.
	Plays []PlaysSpec
}

type RenderConfig struct {
	// PackageName is the name of the Go package for the generated code.
	PackageName string
	// ModulePath is the module import path for the 'gotype' package.
	ModulePath string
	// UseAcronyms, if true, applies Go acronym naming conventions (e.g., 'ID' instead of 'Id').
	UseAcronyms bool
	// SkipAbstract, if true, excludes abstract TypeDB types from the generated Go code.
	SkipAbstract bool
	// SchemaVersion is an optional string included in the generated file header.
	SchemaVersion string
	// Enums, if true, generates string constants from @values constraints on attributes.
	Enums bool
	// WarnWriter receives non-fatal generation warnings (unknown value types,
	// undefined attributes, roles without a resolvable player). When nil,
	// warnings are written to os.Stderr.
	WarnWriter io.Writer
}

type RoleCtx struct {
	RoleName    string
	PlayerTypes []string
	Card        string // e.g. "1", "0..", "1.."
}

type SimpleDef struct {
	Attribute *AttrDef     `parser:"  @@"`
	Entity    *EntityDef   `parser:"| @@"`
	Relation  *RelationDef `parser:"| @@"`
	Struct    *StructDefP  `parser:"| @@"`
	Fun       *FunDef      `parser:"| @@"`
}

type StructDefP struct {
	Name   string         `parser:"'struct' @Ident"`
	Annots []Annotation   `parser:"@@* (':' | ',')"`
	Fields []StructFieldP `parser:"@@ (',' @@)* ','? ';'"`
}

type StructFieldP struct {
	FieldName string       `parser:"( @Ident 'value' | 'value' @Ident )"`
	ValueType string       `parser:"@Ident"`
	Optional  bool         `parser:"@'?'?"`
	Annots    []Annotation `parser:"@@*"`
}

type StructFieldSpec struct {
	// Name is the name of the field.
	Name string
	// ValueType is the TypeQL type of the field's value.
	ValueType string
	// Optional indicates whether the field is marked as optional in the schema.
	Optional bool
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
}

type StructSpec struct {
	// Name is the name of the struct type.
	Name string
	// Doc is the optional @doc annotation text.
	Doc string
	// Meta is the list of @meta annotations.
	Meta []MetaSpec
	// Fields is a list of fields defined within the struct.
	Fields []StructFieldSpec
}

type SubClause struct {
	Parent string       `parser:"'sub' @Ident"`
	Annots []Annotation `parser:"@@*"`
}

type SubkeyAnnot struct {
	Key string `parser:"'@subkey' '(' @Ident ')'"`
}

type TQLFileSimple struct {
	Define      string      `parser:"'define'"`
	Definitions []SimpleDef `parser:"@@*"`
}

type TypeConstCtx struct {
	Name  string // e.g. "TypePersona"
	Value string // e.g. "persona"
}

type ValuesAnnot struct {
	Values []string `parser:"'@values' '(' @String ( ',' @String )* ')'"`
}