rts

type ArgBlock struct {
	BaseNode
	Args []ArgDecl
	// ArgName -> Constraint
	EnumConstraints  map[string]*ArgEnumConstraint
	RegexConstraints map[string]*ArgRegexConstraint
	RangeConstraints map[string]*ArgRangeConstraint
	Requirements     []ArgRequirement
	Exclusions       []ArgExclusion
}

type ArgDecl struct {
	BaseNode
	Name       ArgDeclName
	Type       ArgDeclType
	Rename     *ArgDeclRename
	Shorthand  *ArgDeclShorthand
	Optional   *ArgDeclOptional
	Default    *ArgDeclDefault
	Comment    *ArgDeclComment
	IsVariadic bool
}

type ArgDeclComment struct {
	BaseNode
	Comment string
}

type ArgDeclDefault struct {
	BaseNode
	DefaultString     *string
	DefaultInt        *int64
	DefaultFloat      *float64
	DefaultBool       *bool
	DefaultStringList *[]string
	DefaultIntList    *[]int64
	DefaultFloatList  *[]float64
	DefaultBoolList   *[]bool
}

type ArgDeclName struct {
	BaseNode
	Name string
}

type ArgDeclOptional struct {
	BaseNode
}

type ArgDeclRename struct {
	BaseNode
	ExternalName string
}

type ArgDeclShorthand struct {
	BaseNode
	Shorthand string // single char
}

type ArgDeclType struct {
	BaseNode
	Type string // todo or enum?
}

type ArgEnumConstraint struct {
	BaseNode
	ArgName ArgName
	Values  ArgEnumValues
}

type ArgEnumValues struct {
	BaseNode
	Values []string
}

type ArgExclusion struct {
	BaseNode
	Arg      ArgName
	IsMutual bool
	Excluded []ArgName
}

type ArgName struct {
	BaseNode
	Name string
}

type ArgRangeConstraint struct {
	BaseNode
	ArgName ArgName
	Range   ArgRangeValue
}

type ArgRangeMinMax struct {
	BaseNode
	Value float64
}

type ArgRangeOpenerCloser struct {
	BaseNode
	Token string
}

type ArgRangeValue struct {
	Opener ArgRangeOpenerCloser
	Closer ArgRangeOpenerCloser
	Min    *ArgRangeMinMax
	Max    *ArgRangeMinMax
}

type ArgRegexConstraint struct {
	BaseNode
	ArgName ArgName
	Regex   ArgRegexValue
}

type ArgRegexValue struct {
	BaseNode
	Value string
}

type ArgRequirement struct {
	BaseNode
	Arg      ArgName
	IsMutual bool
	Required []ArgName
}

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

type CallNode struct {
	BaseNode
	Name     string
	NameNode *ts.Node
}

type CallbackType int

type CmdBlock struct {
	BaseNode
	Name        CmdName
	Description *CmdDescription
	Args        []ArgDecl
	// Constraints (reuse from ArgBlock)
	EnumConstraints  map[string]*ArgEnumConstraint
	RegexConstraints map[string]*ArgRegexConstraint
	RangeConstraints map[string]*ArgRangeConstraint
	Requirements     []ArgRequirement
	Exclusions       []ArgExclusion
	// Callback
	Callback CmdCallback
}

type CmdCallback struct {
	BaseNode
	Type           CallbackType
	IdentifierName *string  // For function reference callbacks (CallbackIdentifier)
	LambdaNode     *ts.Node // For inline lambda callbacks (CallbackLambda)
}

type CmdDescription struct {
	BaseNode
	Contents string
}

type CmdName struct {
	BaseNode
	Name string
}

type FileHeader struct {
	BaseNode
	Contents        string
	MetadataEntries map[string]string
}

type FnSignature struct {
	Name      string
	Signature string
	Typing    *rl.TypingFnT
}

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

type Node interface {
	Node() *ts.Node
	CompleteSrc() string
	Src() string
	// Indexes in the original source code.
	// Zero indexed, so add +1 to get human readable values.
	// todo wrap in own Range object instead?
	StartByte() int
	EndByte() int // inclusive
	StartPos() Position
	EndPos() Position // inclusive
}

type Position struct {
	Row int
	Col int
}

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

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

type Shebang struct {
	BaseNode
}

type StringNode struct {
	BaseNode
	RawLexeme string // Literal src, excluding delimiters, ws, comments, etc
}