parser

type Action struct {
	Name   string   `json:"name"`
	Params []*Param `json:"params,omitempty"`
	Steps  []*Call  `json:"steps,omitempty"`
}

type Assertion struct {
	// Expression assertion field
	Expr Expr `json:"expr,omitempty"` // boolean expression (invariants)

	// Path assertion fields
	Expected Expr   `json:"expected,omitempty"` // expected value
	Target   string `json:"target,omitempty"`   // field path or locator name
	Plugin   string `json:"plugin,omitempty"`   // plugin namespace (from @ syntax)
	Property string `json:"property,omitempty"` // assertion property name
}

type Assignment struct {
	Value Expr   `json:"value,omitempty"`
	Path  string `json:"path"`
}

type BinaryOp struct {
	Left  Expr   `json:"left,omitempty"`
	Right Expr   `json:"right,omitempty"`
	Op    string `json:"op"` // ==, !=, >, <, >=, <=, +, -, *, &&, ||
}

type Block struct {
	Assignments []*Assignment `json:"assignments,omitempty"` // concrete values (given blocks)
	Predicates  []Expr        `json:"predicates,omitempty"`  // when-predicate conditions (when blocks)
	Assertions  []*Assertion  `json:"assertions,omitempty"`  // then-block checks
}

type Call struct {
	Namespace string `json:"namespace,omitempty"` // plugin name, empty for local actions
	Method    string `json:"method"`
	Args      []Expr `json:"args,omitempty"`
}

type Contract struct {
	Input  []*Field `json:"input,omitempty"`
	Output []*Field `json:"output,omitempty"`
}

type EnvRef struct {
	Var     string `json:"var"`
	Default string `json:"default,omitempty"`

} // env(VAR) or env(VAR, "default")

type Expr interface {
	// contains filtered or unexported methods
}

type Field struct {
	Constraint Expr     `json:"constraint,omitempty"` // optional constraint expression (nil when absent)
	Name       string   `json:"name"`
	Type       TypeExpr `json:"type"`
}

type FieldRef struct {
	Path string `json:"path"` // e.g., "input.from.balance", "output.error"
}

type ImportRegistry map[string]ImportResolver

type ImportResolver interface {
	Resolve(absPath string) ([]*Model, []*Scope, error)
}

type Invariant struct {
	When       Expr         `json:"when,omitempty"` // optional guard predicate (nil when absent)
	Name       string       `json:"name"`
	Assertions []*Assertion `json:"assertions,omitempty"` // body assertions
}

type LenExpr struct {
	Arg Expr `json:"arg"`
}

type LiteralBool struct {
	Value bool `json:"value"`
}

type LiteralFloat struct {
	Value float64 `json:"value"`
}

type LiteralInt struct {
	Value int `json:"value"`
}

type LiteralNull struct{}

type LiteralString struct {
	Value string `json:"value"`
}

type Model struct {
	Name   string   `json:"name"`
	Fields []*Field `json:"fields,omitempty"`
}

type ObjField struct {
	Value Expr   `json:"value,omitempty"`
	Key   string `json:"key"`
}

type ObjectLiteral struct {
	Fields []*ObjField `json:"fields,omitempty"` // ordered key-value pairs
}

type Param struct {
	Name string   `json:"name"`
	Type TypeExpr `json:"type"`
}

type RegexLiteral struct {
	Pattern string `json:"pattern"`
}

type Scenario struct {
	Given *Block `json:"given,omitempty"` // concrete values
	When  *Block `json:"when,omitempty"`  // predicate block (generative)
	Then  *Block `json:"then,omitempty"`  // assertions
	Name  string `json:"name"`
}

type Scope struct {
	Name       string          `json:"name"`
	Config     map[string]Expr `json:"config,omitempty"` // opaque key-value pairs, interpreted by adapter
	Contract   *Contract       `json:"contract,omitempty"`
	Invariants []*Invariant    `json:"invariants,omitempty"`
	Scenarios  []*Scenario     `json:"scenarios,omitempty"`
}

type Spec struct {
	Uses        []string          `json:"uses,omitempty"`
	Name        string            `json:"name"`
	Description string            `json:"description,omitempty"`
	Target      *Target           `json:"target,omitempty"`
	Locators    map[string]string `json:"locators,omitempty"`
	Models      []*Model          `json:"models,omitempty"`
	Actions     []*Action         `json:"actions,omitempty"`
	Scopes      []*Scope          `json:"scopes,omitempty"`
}

type Target struct {
	Fields map[string]Expr `json:"fields,omitempty"` // key -> value expression (may be EnvRef, LiteralString, etc.)
}

type Token struct {
	Value string
	Type  TokenType
	File  string
	Line  int
	Col   int
}

type TokenType int

type TypeExpr struct {
	Name     string    `json:"name"`                // "int", "string", "bool", "float", "bytes", "array", "map", or model name
	ElemType *TypeExpr `json:"elem_type,omitempty"` // element type for arrays
	KeyType  *TypeExpr `json:"key_type,omitempty"`  // key type for maps
	ValType  *TypeExpr `json:"val_type,omitempty"`  // value type for maps
	Optional bool      `json:"optional,omitempty"`  // trailing ?
}

type UnaryOp struct {
	Operand Expr   `json:"operand,omitempty"`
	Op      string `json:"op"` // !, -
}