record

type ElementArray struct {
	Path    string
	Members []string
}

type Fidelity string

type Field struct {
	// Name is the field's name in the declaration: the key of its value in a
	// source and of its outputs in a result.
	Name string
	// Identity is the last segment of the field's label, under the plan's
	// context. It is the name unless a policy pinned another.
	Identity string
	// Kind is the declared type, or Untyped.
	Kind Kind
	// Outputs are the field's outputs: Ciphertext and/or terms, at least one
	// — unless the field names a Target, which has none of its own.
	Outputs []Output
	// Target is the EQL type the field seals into (encrypt_into), such as
	// TextEq, or "". A field has outputs or a target, never both: the EQL
	// type's own plan decides what is sealed and which terms sit beside it,
	// and the engine returns the finished value under EQLKey.
	Target string
	// Null is how the field stores a value that is not there: NotNull for a
	// field every row has, SealedNull or SQLNull for one declared over a
	// pointer.
	Null Null
	// TargetOptions are the options the field gives its Target: those of
	// the index the target carries. A target that stores a JSON document
	// (JsonSearch) takes the JSON index's; nil runs a target under its
	// defaults, and no other target takes any.
	TargetOptions *TargetOptions
}

type Kind string

type Null string

type Operator struct {
	// Name is the operator's name, as a query names it: eq, lt, lte, gt,
	// gte, between or matches; for a field that stores a JSON document,
	// contains, contained_by, eq_at, lt_at, lte_at, gt_at, gte_at,
	// between_at, selector, subtree, children, child_count, element_match
	// or match.
	Name string
	// Fidelity is how far the server's answer can be trusted.
	Fidelity Fidelity
	// Pair says the operator takes two values, low then high, as between
	// does, where every other takes one.
	Pair bool
	// Index is the index that answers it: the field's, or its EQL type's.
	Index Output
	// Input is the shape of the operator's input, as the engine names it:
	// value (one value of the field's kind), pair (two, low then high),
	// json, path_json, path_pair, path, path_bound, path_predicates or
	// predicate (objects of named inputs, for a document's operators).
	Input string
}

type Output string

type Outputs struct {
	// Ciphertext is the frozen leaf bytes, or nil for an index-only field
	// or a target field.
	Ciphertext []byte
	// Terms are the index terms by output, each its frozen bytes.
	Terms map[Output][]byte
	// EQL is the EQL value's JSON bytes for a field that names a Target.
	EQL []byte
	// Context is the context field's value as the record stores it, in the
	// clear, and nothing for any other field.
	Context string
}

type Plan struct {
	// Context is the label every field's label extends: at least one plain
	// segment. The guest requires a field's label to have two or more
	// segments, which the identity supplies. Empty when ContextField is set.
	Context []string
	// ContextField is the name of the record's field whose value is the
	// context, when the declaration takes its context from a field rather
	// than from Context: the engine's context_field. The field is a string,
	// crosses the binding as a passthrough, and is not in Fields. Each
	// field's label is then its identity alone, under that value.
	ContextField string
	// Extension is the caller's parts, nested to the left of every field's
	// label, in order: a tenant, a region.
	Extension []any
	// Fields are the sealed fields, in declared order.
	Fields []Field
}

type Sealed = map[string]Outputs

type Source = map[string]any

type Target struct {
	// Name is the Go type name, and the value of encrypt_into: TextEq.
	Name string
	// Family and Suffix are the two halves of the name: Text, Eq.
	Family string
	Suffix string
	// Plaintext is the kind the type seals, or Untyped when the entry says
	// null.
	Plaintext Kind
	// SQLDomain is the Postgres domain of the stored value.
	SQLDomain string
	// Indexes are the terms the type carries.
	Indexes []Output
	// Query is the Go type name of the query value, or "" for none.
	Query string
	// QuerySQLDomain is the Postgres domain of the query value, or "".
	QuerySQLDomain string
	// Producible says whether this build of the engine produces the type;
	// Reason says why not when it does not.
	Producible bool
	Reason     string
	// Operators are the operators the engine answers for a field that names
	// the type, in the engine's order; none for a type it does not produce.
	Operators []Operator
}

type TargetOptions struct {
	// SealedRoot says whether the document's root is sealed: its entry
	// holds the whole document, and no token enumerates its top-level
	// members. nil is the default, sealed.
	SealedRoot *bool
	// Ordered are the JSONPath paths ($.age, $.visits[*].at) whose number
	// and string leaves carry an ordering term, so they answer the
	// orderings. None by default.
	Ordered []string
}