@xanots/sdk 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,4477 @@
+import { e1 as Condition, e2 as FilterResults, e3 as ElementResult, e4 as SameArrayResult, e5 as GroupedArrayResult, e6 as AgentResultOf, aZ as AddonDef, e7 as OutputPath, cO as TableDef, e8 as QualifiedCol, br as DbEval, cN as SortDirective, bt as DbWhere, e9 as OutputRoot, bG as InferRow, ea as AggregateRow, eb as EvalFields, ec as OutputAuthored, c0 as MicroserviceDef, ae as generated, F as FunctionDef, cd as QueryHandle } from './store-BQ97nKIF.js';
+export { a_ as AddonXdo, A as AdoptChange, a as AdoptResult, a$ as AgentDef, b0 as AgentHandle, b1 as AgentOutput, b2 as AgentSettingsXdo, b3 as AgentXdo, b4 as AmbientBindings, b5 as AnthropicLlm, b6 as ApiGroupDef, b7 as ApiGroupXdo, b8 as AuthRef, b9 as Authored, B as Bundle, b as BundlePayload, c as BundleType, ba as Capturable, aW as CaptureRecord, aU as CaptureValue, bb as ChannelConversationDef, bc as ChannelDeliveryDef, bd as ChannelDeliveryGuarantee, be as ChannelPublishDef, bf as ChannelPublishWho, bg as ChannelRateLimitDef, bh as ColumnDef, bi as Comparison, bj as ContainerEnv, bk as ContainerPort, bl as ContainerResources, bm as ContainerVolume, bn as CorsConfig, bo as CorsMode, bp as DatabaseActions, bq as DatabaseInputs, bs as DbEvalFilter, bu as ErrorInputs, bv as ExceptionPolicy, bw as FieldAccessor, bx as FieldRule, by as GoogleGenAiLlm, bz as HistoryInput, bA as HttpVerb, bB as IndexDef, bC as IndexLang, bD as IndexOp, bE as IndexType, bF as IndexXdo, bH as InputDescriptor, bI as InputOptions, bJ as IteratingBindings, bK as LAMBDA_BINDINGS, bL as LAMBDA_CODE_FILTERS, bM as LAMBDA_GLOBALS, bN as LAMBDA_MODULE_GLOBALS, bO as LAMBDA_STATEMENTS, aX as LambdaBindings, bP as LambdaBody, aT as LambdaOptions, aV as LambdaSurface, bQ as LlmPrompt, bR as LlmProvider, bS as LlmSettings, f as LockEntry, g as LockExportContext, h as LockFile, M as Manifest, i as ManifestField, j as ManifestKind, k as ManifestStatement, bT as ManifestValue, bU as McpPathOptions, bV as McpServerDef, bW as McpServerHandle, bX as McpServerXdo, l as MergeResult, bY as MessageDeliverTo, bZ as MicroserviceChart, b_ as MicroserviceConfig, b$ as MicroserviceContainer, c1 as MicroserviceDeployment, c2 as MicroserviceIngress, c3 as MicroserviceRegistryAuth, c4 as MicroserviceVolume, c5 as MicroserviceXdo, c6 as MiddlewareAttach, c7 as MiddlewareAttachEntry, c8 as MiddlewareDef, c9 as MiddlewareXdo, O as ObjectKind, ca as OpenAiLlm, m as PayloadArrayKey, cb as QueryDef, cc as QueryFilterName, ce as QueryResponseType, cf as QueryXdo, cg as RealtimeActions, ch as RealtimeChannelActions, ci as RealtimeChannelDef, cj as RealtimeChannelHandle, ck as RealtimeChannelRef, cl as RealtimeChannelTriggerInputs, cm as RealtimeChannelXdo, cn as RealtimeClient, co as RealtimeInputs, cp as RealtimeMessageDef, cq as RealtimeMessageXdo, cr as RealtimeServerActions, cs as RealtimeServerDef, ct as RealtimeServerHandle, cu as RealtimeServerRef, cv as RealtimeServerTriggerInputs, cw as RealtimeServerXdo, cx as RealtimeUrlOptions, R as RenameResult, cy as ResultStrategy, cz as Route, cA as RowOf, cB as ScheduleDef, cC as SchemaCols, cD as SchemaDef, cE as SearchComparison, cF as SearchGroup, cG as SearchNode, cH as SearchOp, cI as SearchParamValue, cJ as SeedFileSource, cK as SeedRow, cL as SeedSource, cM as SortDir, S as StatementSpec, cP as TableXdo, cQ as TaskDef, cR as TaskXdo, cS as ToolDef, cT as ToolXdo, cU as ToolsetBaseDef, cV as ToolsetBaseXdo, cW as ToolsetInputs, cX as ToolsetToolEntry, cY as ToolsetToolRef, cZ as TriggerDef, c_ as TriggerObjType, c$ as TriggerXdo, d0 as ViewDef, d1 as ViewXdo, d2 as WorkflowTestDef, d3 as WorkflowTestXdo, d4 as WorkspaceActions, d5 as WorkspaceConfigDef, d6 as WorkspaceConfigXdo, d7 as WorkspaceHistoryDef, d8 as WorkspaceHistoryXdo, d9 as WorkspaceInputs, da as WorkspaceMiddlewareDef, db as WorkspaceMiddlewareXdo, aY as Xano, dc as XanoFreeLlm, dd as addon, de as agent, df as agentTrigger, dg as and, dh as apiGroup, di as assertLambdaBody, dj as bitwiseAnd, dk as bitwiseOr, dl as bitwiseXor, dm as cmp, dn as defineFunction, dp as emit, dq as emitBundle, dr as errorTrigger, ds as expr, dt as fl, du as input, ed as lam, dv as mathAdd, dw as mathDiv, dx as mathMul, dy as mathSub, dz as mcpServer, dA as mcpServerTrigger, dB as microservice, dC as middleware, dD as mixed, dE as objectEntries, dF as objectKeys, dG as objectValues, dH as or, dI as query, dJ as realtimeChannel, dK as realtimeChannelTrigger, dL as realtimeMessage, dM as realtimeServer, dN as realtimeServerTrigger, dO as realtimeTrigger, dP as resetLockOverrides, dQ as seedFile, dR as seedLockOverrides, dS as table, dT as tableTrigger, dU as task, dV as textAppend, dW as textPrepend, dX as toSearchParams, dY as tool, dZ as workflowTest, d_ as workspace, d$ as workspaceConfig, e0 as workspaceTrigger } from './store-BQ97nKIF.js';
+import { a2 as StatementAnnotations, a1 as Statement, y as FromFieldMap, w as FilterXdo, V as Value, S as ObjValue, aH as Prettify, x as FilteredValue, X as RefValue, aM as AsShapeBrand, aj as XanoFileRef, a4 as StatementOptions, T as ObjectRef, P as ObjInput, F as FunctionXdo } from './response-CVAE2kMj.js';
+export { B as BrandOpts, c as BrandValue, C as CacheXdo, f as CaughtField, h as ConditionalContext, j as ConditionalElifContext, D as DecimalMethod, E as EmailMethod, k as ExprGroup, l as ExprNode, m as ExprOperand, n as ExprStatement, o as FieldAccess, p as FieldDescriptor, q as FieldMap, s as FieldOpts, u as FieldStyleType, v as FieldXdo, H as HistoryXdo, I as InputXdo, z as IntMethod, L as ListBoundsXdo, M as MethodArg, A as MethodOpts, G as MethodSpec, J as MethodXdo, K as MockEntry, N as MockMap, O as MockXdo, Q as ObjMember, U as PasswordMethod, W as PersistedFunctionRow, Y as RegexValue, Z as ResponseDef, _ as ResultItemXdo, $ as RowFromFieldMap, a0 as StackItemXdo, a3 as StatementInputXdo, a5 as TAGS, a6 as TEST_EXPECT_TYPES, a7 as TableRefMethod, a8 as Tag, a9 as TaggedValue, aa as TestDef, ab as TestExpect, ac as TestExpectType, ad as TestXdo, ae as TextFormat, af as TextMethod, ag as TypeBrand, ah as ValueOf, ai as VectorMethod, ak as XanoGeoPosition, al as XanoGeoValue, am as annotate, an as auth, ao as c, ap as caught, aq as col, ar as env, as as expect, at as f, au as filter, av as inp, aw as obj, ax as out, ay as ref, az as resp, aA as setting, aB as statements, aC as sys, aD as test, aE as toolset, aF as withFilters } from './response-CVAE2kMj.js';
+
+/** One `else if (when) { then }` branch of a {@link conditional}'s elif stack. */
+interface ConditionalElifArgs extends StatementAnnotations {
+    when: Condition;
+    then: Statement[];
+}
+interface ConditionalArgs extends StatementAnnotations {
+    when: Condition;
+    then: Statement[];
+    /** Ordered `else if` branches, each `{ when, then }`. */
+    elif?: ConditionalElifArgs[];
+    else?: Statement[];
+}
+/** A branching statement: `if (when) { then } [else if …] else { else }`. */
+declare function conditional(args: ConditionalArgs): Statement;
+
+/**
+ * `InferInput<Q>` (U2) — the request-payload TS type for a query (or function)
+ * def's declared inputs, computed at compile time from the value brands added in
+ * U1. No codegen, no build step: the type is derived from the def, so it can
+ * never drift from what the endpoint actually accepts.
+ *
+ * ```ts
+ * const meQuery = query({ verb: "POST", apiGroup: auth, name: "me",
+ *   input: { email: input.email({ required: true }), password: input.password({ required: true }) } });
+ *
+ * type MePayload = InferInput<typeof meQuery>;   // { email: string; password: string }
+ * fetch(BASE + meQuery.getPath(), { body: JSON.stringify(payload satisfies MePayload) });
+ * ```
+ *
+ * Works for any def carrying an `input` map, so `defineFunction` handles infer
+ * the same way (functions share the input system) even though only queries have
+ * a URL path.
+ */
+
+/**
+ * The `input` map of a def-like `{ input?: ... }`, or an empty map when absent.
+ * The empty case must be `Record<never, never>` (keyof `never`) — NOT
+ * `Record<string, never>`, whose string index signature would make
+ * {@link FromFieldMap} emit an index-signature payload instead of `{}`.
+ */
+type InputMapOf<Q> = Q extends {
+    input?: infer M;
+} ? [M] extends [undefined] ? Record<never, never> : NonNullable<M> : Record<never, never>;
+/**
+ * Turn a query/function def's declared `input` map into its request-payload
+ * type: required inputs become required keys, the rest optional; `nullable`
+ * adds `| null`, `array`/`list` produce `T[]`, `enum` a literal union, and a
+ * nested `object` input recurses.
+ */
+type InferInput<Q> = FromFieldMap<InputMapOf<Q>>;
+
+/**
+ * Filter-aware result typing — what a value becomes after a filter chain runs.
+ *
+ * A filter changes the value at runtime, and until now the type system had no
+ * way to follow: `withFilters(ref("row"), fl.count())` typed as `unknown`, and a
+ * statement's `asFilters` chain did not change the bound variable's type at all
+ * (which was worse — the declared type was a confident lie).
+ *
+ * The engine's own filter catalog declares a `result` for 190 of the 225
+ * filters, and {@link FilterResults} turns those declarations into types. This
+ * module folds a chain over them, left to right, exactly as the engine applies
+ * them — confirmed live: `[fl.first(), fl.get("id")]` over `[{"id":1}]` returns
+ * `1`, so each filter genuinely sees the previous one's output.
+ *
+ * **What this does NOT do.** It does not check that a filter can *accept* the
+ * value it is given. A filter applied to an incompatible value returns `null` at
+ * runtime rather than erroring — `"ab" |trim|lower|count` is `null`, because
+ * `count` is an array filter — so a nonsensical chain still types as its
+ * declared result. Modelling filter INPUT types is separate work; this models
+ * output only.
+ */
+
+/**
+ * The filter name a {@link FilterXdo} carries at the type level.
+ *
+ * `fl.upper()` is a `FilterXdo<"upper">`; the bare `filter(someString)` escape
+ * hatch and every decoded envelope are `FilterXdo<string>`, which widens to the
+ * `string` that {@link ApplyFilter} treats as "not statically known".
+ */
+type NameOf<F> = F extends FilterXdo<infer N> ? N : string;
+/**
+ * Apply ONE filter's declared result to `Shape`.
+ *
+ * Null propagates rather than being erased, matching `IndexShape`'s treatment of
+ * a nullable base (#105) and the engine's runtime, where a filter over a null
+ * binding yields null: a `db.get` row is `Row | null`, so counting it is
+ * `number | null`, not `number`.
+ *
+ * Anything not in {@link FilterResults} — the `any`-result filters (`get`,
+ * `set`, `transform`, `json_decode`, `lambda`, …) and a name that is not
+ * statically known — lands on `unknown`. That is the honest floor, and it is
+ * where this deliberately stops rather than guessing.
+ */
+type ApplyFilter<Shape, N extends string> = string extends N ? unknown : null extends Shape ? ApplyFilter<Exclude<Shape, null>, N> | null : N extends keyof FilterResults ? FilterResults[N] extends ElementResult ? Shape extends readonly (infer E)[] ? E : unknown : FilterResults[N] extends SameArrayResult ? Shape extends readonly unknown[] ? Shape : unknown : FilterResults[N] extends GroupedArrayResult ? Shape extends readonly (infer E)[] ? Record<string, E[]> : unknown : FilterResults[N] : unknown;
+/**
+ * Fold a whole chain over `Shape`, left to right.
+ *
+ * An empty chain leaves the shape untouched, so attaching no filters is exactly
+ * the same type as attaching none — `asFilters: []` does not degrade anything.
+ */
+type ApplyFilters<Shape, Fs> = Fs extends readonly [infer Head, ...infer Tail] ? ApplyFilters<ApplyFilter<Shape, NameOf<Head>>, Tail> : Fs extends readonly [] ? Shape : unknown;
+
+/**
+ * `InferResponse<Q>` (issue #5) — the response type for a query or function def,
+ * the read-side counterpart of `InferInput`. Closes the round trip: rename or
+ * retype what an endpoint returns and every consumer that types a response
+ * against `InferResponse` lights up at compile time.
+ *
+ * ```ts
+ * const listLinks = query({ verb: "GET", apiGroup: links, name: "list_links",
+ *   stack: [s.db.query({ table: link, as: "rows" })], response: ref("rows"),
+ *   responseShape: [] as InferRow<typeof link>[] });
+ *
+ * type Links = InferResponse<typeof listLinks>;   // InferRow<typeof link>[]
+ * const res = await fetch(BASE + listLinks.getPath());
+ * const links: Links = await res.json();          // typed end to end
+ * ```
+ *
+ * **Hybrid resolution** (mirrors how the Xano engine derives its OpenAPI response
+ * schema — a static walk that degrades to `json` where truth isn't statically
+ * knowable):
+ *   1. A declared `responseShape` on the def always wins (the override).
+ *   2. Otherwise the shape is auto-derived from `response` + `stack`
+ *      ({@link DeriveResponse}) — object-literal keys (U2) and a single variable
+ *      traced to a typed `db.get`/`db.query` (U5). A dotted `ref("var.field")`
+ *      traces the base variable, then indexes the subpath into its shape (#93).
+ *   3. Anything the walk can't resolve (filters, lambdas, control-flow vars,
+ *      `set_var`, function-produced vars, streams) resolves to `unknown`, which
+ *      the author narrows or overrides via `responseShape`.
+ */
+
+/**
+ * The author-declared response shape, read from a def's `responseShape` field
+ * (captured by `query()`/`defineFunction()`), or `never` when undeclared.
+ *
+ * Read structurally rather than off the `Res` type argument: an undeclared def
+ * carries `responseShape?: never`, whose optional-collapsed field type is
+ * `undefined` — the `[R] extends [undefined]` gate maps that to `never` (→ route
+ * to derivation). A declared shape's field type is `T | undefined`; stripping the
+ * optional `undefined` with `Exclude` recovers `T` **while preserving a
+ * deliberate `| null`** (e.g. `InferRow<...> | null` stays nullable).
+ */
+type DeclaredResponse<Q> = Q extends {
+    responseShape?: infer R;
+} ? [R] extends [undefined] ? never : Exclude<R, undefined> : never;
+/**
+ * Search a branded stack tuple `S` for the read statement that bound the
+ * variable `Name` (its phantom `__as`), returning that statement's `__shape`.
+ * Mirrors the engine's `findVarSchema`: a one-hop, top-level match. Statements
+ * without the `__as`/`__shape` brand (`set_var`, control flow, function calls)
+ * are skipped, so a ref into one of those falls through to `unknown` — exactly
+ * where the engine falls back to `json`. A widened (non-tuple) stack matches no
+ * head and yields `unknown` too.
+ */
+/**
+ * What a response resolves to when the stack is a plain `Statement[]` rather
+ * than a tuple — the collapse issue #11 reported.
+ *
+ * A widened stack has no heads to walk, so EVERY `as` binding in it is invisible
+ * and every `ref()` bottoms out. Resolving that to `unknown` made the failure
+ * silent and moved the error downstream ("Property 'model_id' does not exist on
+ * type '{}'", in the page that consumes the response). Resolving it to this
+ * named type puts the cause and the two fixes in the error itself.
+ *
+ * The cause is almost always a shared helper typed `Statement[]` spread into the
+ * stack: `...assertOk("res")`. Return `statements(...)` from the helper to keep
+ * the tuple, or declare `responseShape` on this def.
+ */
+interface StackTupleWidened {
+    readonly __xanots_response_not_inferred: "This stack is a `Statement[]`, not a tuple, so no `as` binding in it can be traced. A helper returning `Statement[]` and spread into the stack is the usual cause: return `statements(...)` from the helper (fixed arity), or declare `responseShape` on this def.";
+}
+/**
+ * Is `S` a widened array (not a fixed tuple)? A fixed tuple's `length` is a
+ * literal. A REST tuple (`[DbGet, ...Statement[]]` — what a stack with a helper
+ * spread at the END looks like) has a `number` length too, which is why the
+ * report below is gated on the trace actually failing rather than on this
+ * alone: a binding declared before the spread still traces perfectly.
+ */
+type IsWidenedStack<S> = S extends readonly unknown[] ? number extends S["length"] ? true : false : false;
+/**
+ * Report the collapse only where it actually happened: an unresolved value
+ * (`unknown`) against a stack whose tuple was widened. A ref that still traced —
+ * because it was bound before the spread, in a rest tuple — keeps its type, and
+ * an unresolvable ref in a proper tuple keeps the honest `unknown` floor (it is
+ * a filter/lambda/control-flow case, not a widening one).
+ */
+type ReportWidened<T, S> = IsWidenedStack<S> extends true ? unknown extends T ? StackTupleWidened : T : T;
+type TraceBinding<Name extends string, S> = S extends readonly [infer Head, ...infer Tail] ? Head extends AsShapeBrand<infer As, infer Shape> ? As extends Name ? Name extends As ? Shape : TraceBinding<Name, Tail> : TraceBinding<Name, Tail> : TraceBinding<Name, Tail> : unknown;
+/**
+ * Walk a dotted subpath `Path` into an already-traced binding `Shape`, one
+ * segment at a time: `IndexShape<AgentRunResult<string>, "result">` → `string`.
+ *
+ * **Null-propagating** (#105): when the base is nullable (e.g. a `db.get` row,
+ * `Row | null`), the null flows *through* the projection rather than erasing it —
+ * `IndexShape<Row | null, "slug">` → `string | null`, mirroring the engine's
+ * runtime where `$row.slug` on a missed (null) row is itself null. Without this,
+ * `keyof (Row | null)` narrows to `never` and every dotted ref into a nullable
+ * base would bottom out at `unknown`, silently dropping the #93 projection.
+ *
+ * A segment that genuinely isn't a key of the (non-null) shape — including a
+ * shape that is already `unknown` (whose `keyof` is `never`) — still bottoms out
+ * at `unknown`, the same honest floor as an untraceable whole ref.
+ */
+type IndexShape<Shape, Path extends string> = unknown extends Shape ? IndexStep<Shape, Path> : null extends Shape ? IndexShape<Exclude<Shape, null>, Path> | null : undefined extends Shape ? IndexShape<Exclude<Shape, undefined>, Path> | undefined : IndexStep<Shape, Path>;
+/**
+ * One non-null indexing step for {@link IndexShape}: split the head segment off
+ * `Path` and project it into `Shape`, recursing (back through the null-aware
+ * {@link IndexShape}) for the tail. A segment that isn't a key bottoms out at
+ * `unknown`. Kept separate so the `unknown extends Shape` guard in `IndexShape`
+ * (true for exactly `unknown`/`any` — the bases where null-distribution can't
+ * terminate) routes straight here without looping.
+ */
+type IndexStep<Shape, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Shape ? IndexShape<Shape[Head], Rest> : unknown : Path extends keyof Shape ? Shape[Path] : unknown;
+/**
+ * Resolve a `ref` name against the branded stack `S`. A **dotted** name projects
+ * a subpath (#93): the head names the bound variable (traced via
+ * {@link TraceBinding}) and the tail indexes into that variable's shape (via
+ * {@link IndexShape}), so `ref("generated.result")` types to the completion, not
+ * `unknown`. A bare name traces the whole binding. Stack-variable names are
+ * identifiers (no dots), so the first `.` always splits the variable from the
+ * subpath — matching how the engine resolves `$generated.result`.
+ */
+type TraceVar<Name extends string, S> = Name extends `${infer Base}.${infer Path}` ? IndexShape<TraceBinding<Base, S>, Path> : TraceBinding<Name, S>;
+/**
+ * Resolve one response {@link Value} to its type against the branded stack `S`.
+ *
+ * A FILTERED value resolves its base and then folds the chain over it
+ * ({@link ApplyFilters}), so `withFilters(ref("rows"), fl.count())` is `number`
+ * rather than `unknown`. It used to degrade to `unknown` outright, on the
+ * grounds that a filter reshapes a value with no static signal — true when
+ * written, but the catalog does declare a result for 190 of the 225 filters, and
+ * those declarations are live-verified. The remaining filters (`get`, `set`,
+ * `json_decode`, …) still land on `unknown` through the fold itself.
+ *
+ * Otherwise a branded `ref` traces to the statement that produced it
+ * ({@link TraceVar}); anything else (a non-ref value, an untraceable ref) is
+ * `unknown` — the honest floor.
+ *
+ * A CONSTANT is "anything else". `response: { success: c.bool(true) }` derives
+ * `{ success: unknown }`, not `{ success: boolean }` — `c.*` returns a bare
+ * `Value` carrying no tag brand, so there is nothing here to read the type off.
+ * That mirrors the engine's own static walk, which resolves references and not
+ * values, and it is deliberate rather than a gap: typing a constant's key would
+ * mean branding the return of every constant constructor, and `Value` is the
+ * currency of every statement field in the SDK. Declare `responseShape` when a
+ * client needs those keys typed (issue #79).
+ */
+type ResolveValue<V, S> = V extends ObjValue<infer Members> ? ResolveObj<Members, S> : V extends FilteredValue<infer Base, infer Chain> ? ApplyFilters<ResolveValue<Base, S>, Chain> : V extends RefValue<infer Name> ? TraceVar<Name, S> : unknown;
+/**
+ * Resolve every member of an {@link ObjValue}'s record (issue #118) — the same
+ * walk {@link DeriveResponse} runs over a top-level object literal, one level
+ * down. `obj()` is the SDK's answer for a nested response object, and it used to
+ * cost the caller its types: the members are ordinary {@link Value}s with
+ * ordinary bindings, so there was never a reason they could not trace.
+ *
+ * The widened-stack report ({@link ReportWidened}) is applied per MEMBER rather
+ * than to the record as a whole, so a collapsed tuple still names itself at the
+ * leaf that failed — `{ user: { id: StackTupleWidened } }` — instead of
+ * flattening back into a silent `unknown`.
+ *
+ * A dynamically-built `ObjInput` (no literal to read) maps its index signature
+ * and lands on `{ [key: string]: unknown }` — the honest floor, same as any other
+ * value the walk cannot see through.
+ */
+type ResolveObj<Members, S> = Prettify<{
+    -readonly [K in keyof Members]: ReportWidened<ResolveMember<Members[K], S>, S>;
+}>;
+/**
+ * Resolve one {@link ObjMember} — the member grammar `obj()` accepts, which is
+ * wider than {@link Value}.
+ *
+ * The branch order is load-bearing:
+ *   - a {@link Value} (including a nested `obj()`, a filtered value, or a `ref`)
+ *     goes to {@link ResolveValue}, so `c.*` constants keep the `unknown` floor
+ *     issue #79 documents;
+ *   - a RAW SCALAR literal types itself — `obj({ count: 3 })` really is a number,
+ *     and unlike `c.int(3)` the type is right there to read. A boolean is widened
+ *     explicitly because inference does not treat it like its siblings: `3` and
+ *     `"hi"` widen to `number`/`string` against the `ObjMember` contextual type,
+ *     while `true` survives as the literal (it is a member of `boolean` itself).
+ *     Uniform scalars beat one field inferring narrower than the rest for no
+ *     reason the author can see; `responseShape` states a literal deliberately;
+ *   - an ARRAY resolves element-wise (checked before the record branch, since an
+ *     array is also an object);
+ *   - a nested plain RECORD recurses. This is the spelling `response: { user: {
+ *     id: ref(...) } }` uses — the #133 auto-wrap, which `encodeResponse` hands
+ *     to `obj()` anyway, so the two spellings must and now do infer alike.
+ */
+type ResolveMember<M, S> = M extends Value ? ResolveValue<M, S> : M extends boolean ? boolean : M extends string | number ? M : M extends readonly (infer Element)[] ? ResolveMember<Element, S>[] : M extends object ? ResolveObj<M, S> : unknown;
+/**
+ * Best-effort automatic derivation of a response shape from the def's `response`
+ * field and branded `stack`. Mirrors the Xano engine's static walk:
+ *   - a record response (object literal) → an object with **those keys** (each
+ *     member resolved individually, recursing into a nested `obj()` or plain
+ *     object literal — #118); keys are known regardless of traceability;
+ *   - a single {@link Value} response → resolve it against the stack;
+ *   - no response / an unresolvable shape → `unknown`.
+ * Kept separate from {@link DeclaredResponse} so the user override always wins.
+ */
+type DeriveResponse<Q> = Q extends {
+    response?: infer Resp;
+    stack?: infer S;
+} ? [Resp] extends [undefined] ? unknown : Resp extends Value ? ReportWidened<ResolveValue<Resp, S>, S> : Resp extends Record<string, unknown> ? Prettify<{
+    -readonly [K in keyof Resp]: ReportWidened<ResolveMember<Resp[K], S>, S>;
+}> : unknown : unknown;
+/**
+ * Recover a query/function's response type. A declared `responseShape` wins;
+ * otherwise fall back to automatic derivation (which itself bottoms out at
+ * `unknown` for anything the static walk can't resolve).
+ */
+type InferResponse<Q> = [DeclaredResponse<Q>] extends [never] ? DeriveResponse<Q> : DeclaredResponse<Q>;
+
+/**
+ * Addressing a stored file from a client (issue #31).
+ *
+ * A file column comes back as a {@link XanoFileRef}: a `path` into the vault
+ * plus metadata, and an absolute, authoritative-looking `url`. On a
+ * tenant-scoped environment — which is what `xanots deploy` provisions — that
+ * `url` addresses the instance host and OMITS the `/tenant/<name>` segment every
+ * other URL on that environment carries, so it 404s. The `path` is correct; only
+ * the host prefix is wrong.
+ *
+ * It fails as a broken `<img>` and nothing else: the API response is complete
+ * and every assertion about it passes, because the field IS present, with a real
+ * `size` and real `meta.width`/`meta.height`. Only fetching the URL reveals it.
+ *
+ * {@link fileUrl} joins `path` to the base URL the client already has, which is
+ * correct on a tenant-scoped environment and on an instance workspace alike.
+ * Use it instead of reading `url` directly.
+ */
+
+/**
+ * The URL to fetch a stored file from, built against the base URL the client is
+ * already talking to.
+ *
+ * ```ts
+ * <img src={fileUrl(row.avatar, XANO_HOST) ?? ""} />
+ * ```
+ *
+ * `XANO_HOST` is the backend base URL `xanots deploy --static` injects (and
+ * `xanots sandbox details` prints) — on an ephemeral it already carries the
+ * `/tenant/<name>` segment, which is exactly the part the file's own `url` field
+ * drops.
+ *
+ * Returns `null` for an absent file, so it composes with an optional column.
+ * Falls back to the file's own `url` only when there is no `path` to join.
+ */
+declare function fileUrl(file: XanoFileRef | null | undefined, baseUrl: string): string | null;
+
+/**
+ * `setVar` / `updateVar` statements (U5/U10) — the `!var` family. Both carry
+ * their value in `context` (not `input[]`), a per-statement quirk confirmed by
+ * the golden fixtures. They differ in how the target variable is named:
+ *
+ * - `set_var` declares a *new* stack variable via the top-level `as` slot
+ *   (`var $x1 { value = ... }`) and emits no `output` envelope.
+ * - `update_var` reassigns an *existing* stack variable named inside
+ *   `context.name` (`update $x1 { value = ... }`), has no `as`, and carries a
+ *   lean `output:{filters:[]}` envelope.
+ */
+
+/** Assign `value` to stack variable `as` (`var $as { value = ... }`). */
+declare function setVar(as: string, value: Value, a?: StatementOptions): Statement;
+/** Reassign existing stack variable `name` to `value` (`update $name { value = ... }`). */
+declare function updateVar(name: string, value: Value, a?: StatementAnnotations): Statement;
+
+/**
+ * Hand-authored `!class` control-flow / terminal statements (U10). These carry
+ * PHP transforms in the engine, so they're authored by hand and validated
+ * against persisted fixtures rather than codegen'd. (`conditional` — also a
+ * `!class` special — already lives in `src/statements/conditional.ts`.)
+ *
+ * - `return` / `die` / `debug_log`: carry a single Value in `context`.
+ * - `foreach_break` / `foreach_continue` / `foreach_remove`: empty `context`.
+ */
+
+/** Accept either a bare `Value` or the object form `{ value }` for ergonomics. */
+type ValueArg = Value | {
+    value: Value;
+};
+/** `return <value>` — terminate and return a value. */
+declare function returnValue(value: ValueArg, a?: StatementAnnotations): Statement;
+/**
+ * `die <value>` — terminate the request with an error value.
+ *
+ * The same statement as `s.debug.stop` (both emit `mvp:die`), and the one flat
+ * alias whose name does not mirror its `s.*` path — there is no `s.die`. Despite
+ * living under `debug`, it is real control flow rather than a development aid.
+ * Compare `s.throw`, which raises a catchable named error.
+ */
+declare function die(value: ValueArg, a?: StatementAnnotations): Statement;
+/** `debug_log <value>` — emit a debug log entry. */
+declare function debugLog(value: ValueArg, a?: StatementAnnotations): Statement;
+/** `foreach_break` — break out of the enclosing loop. */
+declare function foreachBreak(a?: StatementAnnotations): Statement;
+/** `foreach_continue` — continue the enclosing loop. */
+declare function foreachContinue(a?: StatementAnnotations): Statement;
+/** `foreach_remove` — remove the current item from the iterated collection. */
+declare function foreachRemove(a?: StatementAnnotations): Statement;
+
+/**
+ * Hand-authored control-flow block statements (U10). These carry non-trivial
+ * transforms in the engine (for, foreach, while, group), so they're authored by
+ * hand — like `conditional` — rather than codegen'd. Each nests a `run[]` stack
+ * encoded through the shared statement encoder, and `while` reuses the
+ * conditional's `encodeComparison`.
+ *
+ * Stored shapes (from the Xano engine's persisted for/foreach/while shapes):
+ *   for     → context: { as, cnt:<Value>,  run:[…] }
+ *   foreach → context: { as, list:<Value>, run:[…] }
+ *   while   → context: { expr:<comparison>, run:[…] }
+ *   group   → context: { run:[…] }
+ *
+ * All four are golden-verified: `for`/`foreach` from vendored goldens, and
+ * `while`/`group` from live engine captures (see the conformance corpus). The
+ * `while` shape (`expr` comparison + `run[]`) and `group`'s bare `{run}` are
+ * confirmed byte-exact.
+ */
+
+interface ForArgs extends StatementOptions {
+    /** Loop variable name (the index). */
+    as: string;
+    /** Iteration count. */
+    count: Value;
+    body: Statement[];
+}
+/** `for (as in 0..count) { body }` — count-bounded loop. */
+declare function forLoop(args: ForArgs): Statement;
+interface ForeachArgs extends StatementOptions {
+    /** Loop variable name (the current item). */
+    as: string;
+    /** The list to iterate. */
+    list: Value;
+    body: Statement[];
+}
+/** `foreach (as of list) { body }` — list iteration. */
+declare function foreachLoop(args: ForeachArgs): Statement;
+interface WhileArgs extends StatementAnnotations {
+    when: Condition;
+    body: Statement[];
+}
+/** `while (when) { body }` — condition-bounded loop. */
+declare function whileLoop(args: WhileArgs): Statement;
+/** `group { body }` — a labeled block grouping a sub-stack. */
+declare function group(body: Statement[], a?: StatementAnnotations): Statement;
+
+/**
+ * Hand-authored branching block statements (U10) — `switch` and `try_catch`.
+ * Both carry structural control-flow transforms in the engine, so
+ * (like `conditional` and the loops) they're authored by hand rather than
+ * codegen'd. Each nests `run[]` stacks encoded through the shared statement
+ * encoder.
+ *
+ * Stored shapes (from the Xano engine's persisted switch / try_catch shapes):
+ *   switch      → context: { value:<Value>, elif:{ run:[switch_case…] }, else:{ run:[…] } }
+ *   switch_case → context: { value:<Value>, break?:bool, if:{ run:[…] } }
+ *   try_catch   → context: { if:{ run:[…try…] }, else:{ run:[…catch…] }, then:{ run:[…finally…] } }
+ *
+ * In `switch`, `value` is the subject being matched and each `switch_case`'s
+ * `value` is the literal a case compares against; `else.run` is the `default`
+ * block. `break` (fallthrough control) is omitted unless explicitly set, matching
+ * the golden fixture. In `try_catch`, the engine maps try→`if`, catch→`else`,
+ * finally→`then`; all three blocks are always emitted (engine `exportContext`
+ * normalizes each to `{ run: [] }`).
+ */
+
+interface SwitchCaseArgs extends StatementAnnotations {
+    /** The literal this case matches against the switch subject. */
+    when: Value;
+    /** Statements run when this case matches. */
+    body: Statement[];
+    /**
+     * Whether to stop after this case (`true`) or fall through to the next
+     * (`false`). Omitted from the stored shape entirely when not set.
+     */
+    break?: boolean;
+}
+/** A single `case (when) { body }` clause of a `switch`. */
+declare function switchCase(args: SwitchCaseArgs): Statement;
+interface SwitchArgs extends StatementAnnotations {
+    /** The subject value being matched. */
+    on: Value;
+    /** Ordered `case` clauses. */
+    cases: SwitchCaseArgs[];
+    /** The `default` block, run when no case matches. */
+    default?: Statement[];
+}
+/** `switch (on) { case … default … }` — multi-way branch. */
+declare function switchStatement(args: SwitchArgs): Statement;
+interface TryCatchArgs extends StatementAnnotations {
+    /** The protected block (engine `if`). */
+    try: Statement[];
+    /** Error-handler block (engine `else`). */
+    catch?: Statement[];
+    /** Always-run block (engine `then`). */
+    finally?: Statement[];
+}
+/** `try_catch { try … catch … finally … }` — error handling block. */
+declare function tryCatch(args: TryCatchArgs): Statement;
+
+/**
+ * Shared coercion plumbing for the hand-authored statement wrappers — the units
+ * that turn an ergonomic, literal-friendly authored field into the `Value` the
+ * generated factory encodes, so the wrapper delegates for byte-parity.
+ *
+ * Two families live here. The HTTP-request fields (`api.request`,
+ * `stream.from_request`, `webflow.request`, `microservice.request`) were hoisted
+ * per the rule of three once the second wrapper landed. The DB row CELL joined
+ * them (issue #92): it is a self-contained coercion unit that landed in `db.ts`
+ * only because that is where its caller is, and its siblings — `coerceScalar`,
+ * `coerceObj`, `coerceHeaders` — were already here.
+ */
+
+/**
+ * The HTTP verbs the engine's runtime input schema accepts. Enforced: the
+ * wrapper coerces to a `Value` and delegates to the generated factory, whose
+ * spec now carries the same set and rejects a constant outside it.
+ */
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH";
+/** A headers map: full header lines built from `Name: value` pairs (issue #72). */
+type HeaderMap = Readonly<Record<string, string | Value>>;
+/**
+ * A value acceptable in a call/agent `input` map — a raw scalar literal, a nested
+ * object/array, or a tagged {@link Value}. Widening the maps to this lets
+ * `input: { max_age_days: 3 }` compile without wrapping every literal in `c.int`.
+ */
+type InputValue = string | number | boolean | object | Value;
+/** The shared TLS/HTTP fields carried by `api.request` / `stream.from_request` / `webflow.request`. */
+interface HttpRequestFields {
+    method?: HttpMethod | (string & {}) | Value;
+    params?: object | Value;
+    headers?: readonly string[] | HeaderMap | Value;
+    timeout?: number | Value;
+    follow_location?: boolean | Value;
+    verify_host?: boolean | Value;
+    verify_peer?: boolean | Value;
+    ca_certificate?: string | Value;
+    certificate?: string | Value;
+    certificate_pass?: string | Value;
+    private_key?: string | Value;
+    private_key_pass?: string | Value;
+}
+/**
+ * The bare JS literals a row cell accepts for a column whose row type is `V`,
+ * mirroring the `Scalar` union `fl.*` arguments and `seed` rows already take
+ * (issue #75).
+ *
+ * Keyed on the column's own inferred type, so the widening is STRICTER than the
+ * tagged spelling it replaces: `{ is_hidden: "yes" }` on an `f.bool()` column is
+ * a compile error here, where `{ is_hidden: c.text("yes") }` was always accepted.
+ * An `f.enum` column keeps its literal union, so a non-member is refused too.
+ *
+ * `null` is admitted on EVERY column, including the ones that refuse every other
+ * literal — an `obj`/`json`/list/`geo`/`vector` column has no bare-literal form
+ * and throws for a string, number or boolean, but takes `null`. That asymmetry
+ * is the decision, not an oversight (issue #90): nulling a cell is a legitimate
+ * write whatever the column reads back as, and it matches what a seed row does
+ * with a `null` (see `coerceScalarValue` — nullability is the engine's to
+ * enforce, and a column config this layer does not fully model is not something
+ * to guess at). Two consequences worth knowing, both stated on the grounding
+ * surface: on a column with no literal form, `null` is the ONLY literal the cell
+ * type offers; and an explicit `null` is not the same as omitting the key, which
+ * takes the type default in {@link defaultCell} instead.
+ *
+ * A column whose inferred value is `unknown` — a raw `ColumnDef[]` schema, or an
+ * `f.json()` column, which reads back as `unknown` by construction — has nothing
+ * to key on, so it falls back to the whole scalar union and leans on the
+ * encoder's own check. The escape hatch is not made stricter than it was.
+ */
+type ScalarCell<V> = [unknown] extends [V] ? string | number | boolean | null : (V extends string | number | boolean ? V : never) | null;
+
+/**
+ * Background execution for a call statement.
+ *
+ * Shared by `function.run` and `ai.agent.run`: the engine reads the SAME
+ * top-level `runtime` block for both, in one `switch` over `runtime.mode`.
+ * Keeping the model in one place is what stops the two surfaces drifting into
+ * different vocabularies — which is exactly what had happened before this
+ * module existed.
+ */
+/**
+ * How a call executes: synchronously (the default), or in the background on
+ * shared or dedicated async workers.
+ *
+ * Stored as a TOP-LEVEL `runtime` block on the stack item — not inside
+ * `context`. The engine switches on `runtime.mode` and treats every value
+ * outside this union (including the absent block and the editor's explicit
+ * `"disabled"`) as synchronous.
+ *
+ * Async is not a performance knob — it changes what the statement returns.
+ * `mvp:function` is rewritten to `mvp:async_function`, so the call no longer
+ * yields the function's result; it dispatches and continues. Pair it with
+ * `s.await(...)` to collect results.
+ */
+type AsyncMode = "async-shared" | "async-dedicated";
+/** Background execution settings for a call. */
+interface AsyncRuntime {
+    /**
+     * `"async-shared"` runs on the instance's pooled async workers and reads no
+     * other member here. `"async-dedicated"` reserves its own resources and is
+     * the only mode for which `cpu`/`memory`/`timeout`/`maxRetry` are read.
+     */
+    mode: AsyncMode;
+    /** Dedicated only. Kubernetes CPU request — e.g. `"100m"`, `"250m"`, `"500m"`. */
+    cpu?: string;
+    /** Dedicated only. Kubernetes memory request — e.g. `"256Mi"`, `"512Mi"`, `"1Gi"`. */
+    memory?: string;
+    /** Dedicated only. Seconds before the run is abandoned. */
+    timeout?: string | number;
+    /** Dedicated only. Retries after a failed run. */
+    maxRetry?: string | number;
+}
+
+/**
+ * Hand-authored call-family block statements (U10) — invoking another workspace
+ * object from a stack. These carry `!class` transforms in the engine
+ * (FunctionRun, FunctionCall, ApiCall, …) so they're authored by hand.
+ *
+ * Each stores a **cross-object reference** to its target. In a packageExport
+ * bundle that reference is the target's guid (the engine's exportTypeId maps a
+ * local id → guid on export); xanots resolves the authored target → its
+ * deterministic guid via `resolveRef` (see refs/guid.ts), so the emitted call
+ * and the target object's payload `guid` agree and the import remaps both.
+ *
+ * Stored shapes (from the Xano engine's persisted context shapes):
+ *   function.run     → mvp:function                 ctx { function: { id:<guid> } }   [+input]
+ *   function.call    → mvp:workspace_run_function    ctx { id:<guid> }                 [+input]
+ *   api.call         → mvp:workspace_run_endpoint     ctx { id:<guid> }                 [+input]
+ *   task.call        → mvp:workspace_run_task         ctx { id:<guid> }
+ *   tool.call        → mvp:workspace_run_tool         ctx { id:<guid> }                 [+input]
+ *   trigger.call     → mvp:workspace_run_trigger      ctx { id:<guid> }                 [+input]
+ *   middleware.call  → mvp:workspace_run_middleware   ctx { id:<guid> }                 [+input]
+ *   addon.call       → mvp:workspace_run_addon        ctx { id:<guid> }                 [+input]
+ *
+ * The target object's id resolves to a guid keyed by the engine's migrate
+ * *type*: function.run/call → "function", api.call → "query" (an API endpoint
+ * is a `query` object), and the rest map name-for-name.
+ *
+ * Scope: connected-service functions are OUT, permanently — they were never
+ * released in Xano, so no engine produces the shape and no workspace can hold
+ * one. `mvp:function` therefore has exactly one authoring surface, storing the
+ * default payload. Async execution IS modelled (see {@link AsyncRuntime});
+ * api.call emits the `headers`/`auth` blocks (verb/name/api_group are
+ * engine-derived, not stored).
+ *
+ * @TODO(byte-verify): `function.run` (mvp:function), `api.call` (context.token
+ *   confirmed tagged), and — since the workflow-test capture — `function.call`
+ *   (mvp:workspace_run_function) are golden-verified. Still modeled/unverified:
+ *   - the remaining `workspace_run_*` (task/tool/trigger/middleware/addon) — no
+ *     golden, but they share the single-key `id` context two goldens now pin.
+ *   - `workflow_test` → context.{datasource,id} — decode-accurate, no golden.
+ *   - action / action_package — EXCLUDED from byte-verify: they need an
+ *     action-identity model first (action id currently resolves via the "function"
+ *     migrate type, likely wrong; action_package is emitted empty). See their own
+ *     @TODOs below — do not vendor/capture until the identity model exists.
+ */
+
+/** A call/agent `{name: value}` input map — raw scalar literals coerce to constants. */
+type CallInput = Record<string, InputValue>;
+/**
+ * A call's target function — a def handle or name, or `null` for the engine's own
+ * empty binding (`context.function.id: ""`).
+ *
+ * ⚠ **Do not author `null`.** It is a BROKEN state in Xano, not a neutral one:
+ * the statement calls nothing. It exists so `codegen` can represent a broken
+ * statement faithfully rather than degrade it to `raw()` — a pulled `fn: null` is
+ * a defect to fix in the pulled workspace, not a shape to copy. Same contract as
+ * a db statement's `table` and an addon's, which is where the pattern comes from.
+ */
+type FnRef = ObjectRef | null;
+interface FunctionRunArgs<Fn extends FnRef = FnRef, As extends string = string> extends StatementOptions {
+    /** The target function (def handle or name), or `null` when unbound. */
+    fn: Fn;
+    /** Capture the result into this stack variable. */
+    as?: As;
+    /** Input bindings, keyed by the target's input names. */
+    input?: CallInput;
+    /**
+     * Run the function in the background instead of inline. Omit for a normal
+     * synchronous call. See {@link AsyncRuntime} — an async call does NOT return
+     * the function's result.
+     */
+    runtime?: AsyncRuntime;
+}
+/**
+ * `function.run <fn>` — run another function inline.
+ *
+ * Branded `AsShapeBrand<As, InferResponse<Fn>>` (issue #209): the bound variable
+ * carries the TARGET's response type, so `ref("<as>.field")` in the caller's
+ * response types to that field instead of `unknown`. See {@link functionCall}
+ * for what the propagation can and cannot see.
+ *
+ * An ASYNC run (`runtime`) is deliberately still branded with the function's
+ * shape: the engine binds a job handle rather than the result, but `runtime` is
+ * an authored value the type system reads as a whole `AsyncRuntime` regardless
+ * of what it holds, so narrowing on it would be a guess. Declare `responseShape`
+ * on the caller if an async run's binding reaches the response.
+ */
+declare function functionRun<const Fn extends FnRef = FnRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: FunctionRunArgs<Fn, As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<InferResponse<Fn>, Fs>>;
+interface FunctionCallArgs<Fn extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    fn: Fn;
+    as?: As;
+    input?: CallInput;
+}
+/**
+ * `function.call <fn>` — invoke a function as a workspace run.
+ *
+ * Branded `AsShapeBrand<As, InferResponse<Fn>>` (issue #209). `InferResponse` of
+ * the TARGET is exactly what a client would get back from it, so drilling into
+ * the binding now types:
+ *
+ * ```ts
+ * stack: [s.function.call({ fn: calculateDiscount, input: {…}, as: "discount" })],
+ * response: { cents: ref("discount.discount_cents") },   // number, was unknown
+ * ```
+ *
+ * What it can see is what `InferResponse` can see on the target: a declared
+ * `responseShape` always, and otherwise the target's own auto-derivation (object
+ * literal keys, a variable traced to a typed `db.*`). A target whose response
+ * bottoms out at `unknown` — or one named by STRING rather than by def handle,
+ * where there is no def to read — propagates that `unknown` unchanged. Declaring
+ * `responseShape` on the TARGET fixes every caller at once, which is why that
+ * remains the recommendation for a response the walk cannot resolve.
+ */
+declare function functionCall<const Fn extends ObjectRef = ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: FunctionCallArgs<Fn, As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<InferResponse<Fn>, Fs>>;
+interface ApiCallArgs<Api extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    /** The target API endpoint (a `query` object). */
+    api: Api;
+    as?: As;
+    input?: CallInput;
+    /**
+     * Replace the request headers the called endpoint sees. Same shape as
+     * `s.api.request`'s: a `{ "Name": value }` record (values may be tagged), a
+     * `string[]` of full `"Name: value"` lines, or one whole `Value`.
+     *
+     * ⚠ This is the ONLY slot that authenticates a call with a token computed
+     * during the run — an `Authorization` header is read and applied as the
+     * caller's token, while `auth.token` is a static string (see {@link ApiCallArgs.auth}):
+     *
+     * ```ts
+     * s.api.call({ api: signup, input: {…}, as: "signup" }),
+     * s.api.call({ api: checkout, headers: { Authorization: ref("signup.authToken") } }),
+     * ```
+     *
+     * Send `Authorization` only to an endpoint that declares `auth` — the engine
+     * enforces that the token's table matches the target's, and a target with no
+     * `auth` rejects any token as belonging to a different object type.
+     */
+    headers?: readonly string[] | HeaderMap | Value;
+    /**
+     * Authenticate the call with a STATIC token, and optionally ignore its expiry.
+     *
+     * ⚠ `token` is stored in a slot the engine declares as plain text and does NOT
+     * evaluate, so a tagged `Value` — `ref("signup.authToken")`, `env("TOKEN")` —
+     * is rejected at runtime with `Param: token - Text filter requires an integer,
+     * float, string or boolean value`, even though it deploys clean. Only a bare
+     * **string** runs. For a token minted during the run, use an `Authorization`
+     * entry in {@link ApiCallArgs.headers} instead.
+     *
+     * The `Value` spelling stays accepted so a pulled workspace holding one
+     * round-trips as itself (issue #139) — it is a shape to carry, not to author.
+     */
+    auth?: {
+        token: Value | string;
+        ignoreExpiration?: boolean;
+    };
+}
+/**
+ * `api.call <endpoint>` — invoke an API endpoint as a workspace run. The stored
+ * `context` is `{ id, headers?, token?, token_ignore_expiration? }` (the engine
+ * derives name/verb/api_group from the referenced query at encode time, so they
+ * are intentionally NOT stored). Shape modeled on the engine's stored api-call format.
+ *
+ * `context.headers` is a tagged value the engine EVALUATES, so it carries a
+ * runtime-computed `Authorization`. `context.token` is not: the engine declares
+ * that slot as plain text, so a tagged token round-trips byte-for-byte (the
+ * golden pins that) and is then rejected the moment the statement runs. See
+ * {@link ApiCallArgs.auth}.
+ */
+declare function apiCall<const Api extends ObjectRef = ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: ApiCallArgs<Api, As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<InferResponse<Api>, Fs>>;
+interface TaskCallArgs extends StatementOptions {
+    /** The target background task. */
+    task: ObjectRef;
+    as?: string;
+}
+/** `task.call <task>` — invoke a task as a workspace run (no input). */
+declare function taskCall(args: TaskCallArgs): Statement;
+interface ToolCallArgs<Tool extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    tool: Tool;
+    as?: As;
+    input?: CallInput;
+}
+/**
+ * `tool.call <tool>` — invoke a tool as a workspace run. Branded with the
+ * TARGET's `InferResponse` (issue #209), like {@link functionCall}.
+ */
+declare function toolCall<const Tool extends ObjectRef = ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: ToolCallArgs<Tool, As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<InferResponse<Tool>, Fs>>;
+interface TriggerCallArgs extends StatementOptions {
+    trigger: ObjectRef;
+    as?: string;
+    input?: CallInput;
+}
+/** `trigger.call <trigger>` — invoke a trigger as a workspace run. */
+declare function triggerCall(args: TriggerCallArgs): Statement;
+interface MiddlewareCallArgs extends StatementOptions {
+    middleware: ObjectRef;
+    as?: string;
+    input?: CallInput;
+}
+/** `middleware.call <middleware>` — invoke middleware as a workspace run. */
+declare function middlewareCall(args: MiddlewareCallArgs): Statement;
+interface AddonCallArgs extends StatementOptions {
+    addon: ObjectRef;
+    as?: string;
+    input?: CallInput;
+}
+/** `addon.call <addon>` — invoke an addon as a workspace run. */
+declare function addonCall(args: AddonCallArgs): Statement;
+interface ActionCallArgs extends StatementOptions {
+    /** The action's name. */
+    action: ObjectRef;
+    /** The action package identifier. */
+    package?: string;
+    as?: string;
+    input?: CallInput;
+}
+/**
+ * `action.call <action>` — invoke a marketplace/action operation (`mvp:action`).
+ * Stored shape from the engine's action-call format: `context.run_version.id` is the action
+ * id and `settings_registry` is always present.
+ *
+ * @TODO(byte-verify): xanots has no `action` kind, so the id resolves via the
+ *   "function" migrate type — likely WRONG (actions are a distinct namespace,
+ *   `mapActionNameToId`). input[] uses the lean shape; the engine uses
+ *   `convertBlockToInput` (may be the rich form). No golden.
+ */
+declare function actionCall(args: ActionCallArgs): Statement;
+/**
+ * `action.package.call <action>` — invoke an action-package operation
+ * (`mvp:action_package`). Stored shape from the engine's action-package format:
+ * `context.{action:{trace_id}, package:{slug}, package_version:{id}}`.
+ *
+ * @TODO(byte-verify): MODELED skeleton only — xanots doesn't model marketplace
+ *   action packages (trace_id / package slug / version id come from
+ *   `mapActionPackageNameToId`), so these are emitted EMPTY. This statement is a
+ *   reachable placeholder, NOT functional, until the action-package identity model
+ *   exists. No golden.
+ */
+declare function actionPackageCall(args: ActionCallArgs): Statement;
+interface WorkflowTestCallArgs extends StatementOptions {
+    /** The target workflow test. */
+    workflowTest: ObjectRef;
+    as?: string;
+    /** Data source to run against. */
+    datasource?: string;
+}
+/**
+ * `workflow_test.call <test>` — run a workflow test
+ * (`mvp:workspace_run_workflow_test`). Stored shape from the engine's workflow-test format:
+ * `context.{datasource, id}` — `datasource` is ALWAYS present (default `""`).
+ */
+declare function workflowTestCall(args: WorkflowTestCallArgs): Statement;
+
+/**
+ * Hand-authored AI-agent and cloud-job specials (U10). All carry `!class`
+ * transforms in the engine (AgentRun, CloudJob, CloudJobAwait, CloudJobStatus).
+ * The stored shapes here are modeled on those transforms' `decode()` methods
+ * (authoritative for the persisted form), so they're grounded — but still have
+ * no golden fixture to deep-equal against.
+ *
+ * call_agent and cloud_job{,_await,_status} are golden-verified against live
+ * engine captures (see the conformance corpus): agent → context.toolset.id +
+ * top-level runtime + input[]; cloud jobs → everything in input[] with the
+ * captured entry order. `runtime` is omitted at the default "shared" mode, and
+ * `await` is passed through as authored.
+ */
+
+/**
+ * The rich result object an agent run binds to its `as` variable — modeled on
+ * the engine's agent-run result envelope (issue #89). **The completion is at
+ * `.result`**, not the top level; the surrounding fields are run metadata.
+ *
+ * `R` is the completion type: `string` for a text agent (the default — including
+ * `xano-free`), or an object when structured outputs (a schema) are enabled. When
+ * the run targets an agent *handle* it is inferred from that agent's `output.schema`
+ * automatically; the `resultShape` witness on {@link AiAgentRunArgs} overrides it.
+ *
+ * `finishReasonCandidate`/`toolCalls`/`usage`/`totalUsage` are optional: they are
+ * absent or empty depending on the run (no tools, single provider, engine
+ * version), so a returned envelope may carry only a subset.
+ */
+interface AgentRunResult<R = string> {
+    /** The model's completion — the field almost every caller wants. `string` unless structured outputs are enabled (then an object, inferred from the agent's `output.schema`). */
+    result: R;
+    /** Why generation stopped: `'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' | 'unknown'`. */
+    finishReason: string;
+    /** Provider-specific metadata (e.g. usage counters, safety signals), keyed by provider. */
+    providerMetadata: Record<string, Record<string, unknown>>;
+    /** Reasoning parts emitted by the model; `[]` when none. */
+    reasoningDetails: unknown[];
+    /** Per-step records (each with e.g. `text`, `finishReason`, `usage`, `toolCalls`, `providerMetadata`). */
+    steps: unknown[];
+    /** Fallback finish reason, populated only when `finishReason` is `'unknown'`; otherwise empty/absent. */
+    finishReasonCandidate?: string;
+    /** Merged tool-call + result records; absent or empty when no tools ran. */
+    toolCalls?: unknown[];
+    /** Token usage for the final generation (`inputTokens`, `outputTokens`, `totalTokens`, …). */
+    usage?: Record<string, unknown>;
+    /** Token usage aggregated across all steps. */
+    totalUsage?: Record<string, unknown>;
+}
+interface AiAgentRunArgs<As extends string = "", A extends ObjectRef = ObjectRef, R = AgentResultOf<A>> extends StatementOptions {
+    /** The target agent (toolset of type agent — def handle or name). */
+    agent: A;
+    /** The stack variable this run binds. Captured literally so `InferResponse` can trace a `ref` back to the typed {@link AgentRunResult}. */
+    as?: As;
+    /**
+     * Run arguments passed to the agent. Pass a single {@link Value}, or an object
+     * literal of values (`{ question: inp("question") }`) which is built into a
+     * dynamic object via {@link obj}. This becomes the agent's `$args` Twig
+     * namespace: the agent's string settings (system prompt, prompt, model,
+     * provider config) reference these as `{{ $args.propertyName }}`, resolved per
+     * invocation before the LLM call. (Env vars are `{{ $env.NAME }}`.) See
+     * `kinds/agent.ts` for the full templating rules.
+     */
+    args?: Value | ObjInput;
+    /** Whether the agent may execute its tools. */
+    allowToolExecution?: Value;
+    /** Pinned agent version. */
+    version?: Value;
+    /**
+     * Run the agent in the background instead of inline. Omit for a normal
+     * synchronous call. Shares {@link AsyncRuntime} with `function.run` — the
+     * engine reads the same top-level block for both.
+     */
+    runtime?: AsyncRuntime;
+    /**
+     * Type-only override for the `.result` completion type. Usually unnecessary:
+     * when `agent` is a def handle from `agent({ output: { schema } })`, `.result`
+     * is inferred straight from that schema via {@link AgentResultOf} (issue
+     * #124.1). Pass a witness only to override that inference or to type the
+     * `.result` of an agent referenced by bare name (which carries no schema) —
+     * e.g. `resultShape: {} as { sentiment: string }`. Never emitted into the
+     * statement (phantom, like the response brand).
+     */
+    resultShape?: R;
+}
+/**
+ * `ai.agent.run <agent>` — invoke an AI agent (`mvp:call_agent`). Stored shape
+ * from the engine's agent-run format: the target is `context.toolset.id`, `runtime` is a
+ * TOP-LEVEL `{ mode }` block, and `args`/`allow_tool_execution`/`version` are
+ * `input[]` entries (NOT context). `runtime` is emitted only when a mode is set.
+ *
+ * Branded with `AsShapeBrand<As, AgentRunResult<R>>` (like the `db.*` producers)
+ * so `ref(as)` traces to the typed {@link AgentRunResult} envelope via
+ * `InferResponse` instead of `unknown` — the completion is at `.result` (#89).
+ * A dotted `ref("<as>.result")` now projects that completion directly (#93), so
+ * the common "return just the answer" endpoint no longer needs a `responseShape`.
+ * The brand is phantom; the emitted statement bytes are unchanged.
+ */
+declare function aiAgentRun<const As extends string = "", const A extends ObjectRef = ObjectRef, R = AgentResultOf<A>, const Fs extends readonly FilterXdo[] = readonly []>(a: AiAgentRunArgs<As, A, R> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<AgentRunResult<R>, Fs>>;
+interface CloudJobArgs extends StatementOptions {
+    as?: string;
+    image?: Value;
+    command?: Value;
+    args?: Value;
+    secret?: Value;
+    template?: Value;
+    /** Seconds to await completion (default 60). */
+    await?: Value;
+}
+/**
+ * `cloud.job { … }` — launch a containerized cloud job (`mvp:cloud_job`). Stored
+ * shape from the engine's cloud-job format: every block (image/command/args/secret/template/
+ * await) is an `input[]` entry; `context` is empty.
+ *
+ * Golden-verified against a live capture: the input[] entry order
+ * (image→command→args→secret→template→await) matches the persisted shape.
+ */
+declare function cloudJob(a: CloudJobArgs): Statement;
+interface CloudJobAwaitArgs extends StatementOptions {
+    as?: string;
+    /** Job ids to await. */
+    ids: Value;
+    /** Timeout in seconds. */
+    timeout: Value;
+}
+/**
+ * `cloud.job.await { … }` — wait for cloud jobs to finish (`mvp:cloud_job_await`).
+ * `ids`/`timeout` are `input[]` entries with empty context (per the engine's cloud-job-await format).
+ */
+declare function cloudJobAwait(a: CloudJobAwaitArgs): Statement;
+interface CloudJobStatusArgs extends StatementOptions {
+    as?: string;
+    /** The job id to query. */
+    id: Value;
+}
+/**
+ * `cloud.job.status { … }` — read a cloud job's status (`mvp:cloud_job_status`).
+ * `id` is an `input[]` entry with empty context (per the engine's cloud-job-status format).
+ */
+declare function cloudJobStatus(a: CloudJobStatusArgs): Statement;
+
+/**
+ * Hand-authored miscellaneous specials (U10) — the remaining `!class` /
+ * `!function` / declarative statements without a generated factory: array
+ * map/union, the comment & placeholder nodes, raw-input access, post-process,
+ * realtime events, auth-token creation, and the `expect.to_throw` test
+ * assertion.
+ *
+ * `comment`, `realtime_event`, and `create_auth` have declarative transforms in
+ * the engine schema and are encoded to match them; the rest are `!class` with no
+ * persisted golden yet, so they are **structural** (reachable, byte-verified
+ * later). Block fields map to same-named `context` entries unless the schema's
+ * declarative transform says otherwise.
+ *
+ * array_map, array_union, get_input, and test_expect_to_throw are now
+ * golden-verified against live engine captures (see the conformance corpus);
+ * post_process is parser-verified. Remaining unverified spots:
+ *   (1) array_map — the scalar `transform_value` path is byte-exact. The
+ *       object-literal form (`transform_object` + `output_type:"object"`) is now
+ *       authorable and round-trips through codegen, but is modeled from the
+ *       engine's declared context schema rather than a capture: no golden yet.
+ *   (2) create_auth — input order is `id/dbtable/extras/expiration`, read from the
+ *       engine's own input schema; `extras`/`expiration` are `?=` optionals and
+ *       are omitted when unset. Only the `dbtable` const tag is unverified.
+ *   (3) realtime_event — context.{channel,data,auth.{dbo_id,row_id}} CONFIRMED by
+ *       the schema transform (auth_table via !map:dbo:constant → table guid).
+ */
+
+interface ArrayMapArgs extends StatementOptions {
+    /** The source array → stored `collection`. */
+    source: Value;
+    as?: string;
+    /**
+     * How each item maps. Three forms, and the form picks the engine's `output_type`:
+     * - a single {@link Value} → each item maps to that scalar expression
+     *   (`output_type:"value"`, stored `transform_value`);
+     * - a record of values → each item maps to an OBJECT with those keys
+     *   (`output_type:"object"`, stored `transform_object[]`);
+     * - a list of `{key, value}` pairs → the same object form, for the keys a
+     *   record cannot hold: one the engine COMPUTES per item, or two rows sharing
+     *   a key (see {@link ArrayMapAttribute}).
+     *
+     * Use `ref("$this")` for the current item and `ref("$index")` for its position.
+     * An empty record is rejected — the engine's object branch iterates
+     * `transform_object` and would map every item to `{}`.
+     */
+    transform?: Value | Record<string, Value> | ArrayMapAttribute[];
+}
+/**
+ * One key/value pair of an object transform, for the shapes a record cannot
+ * hold.
+ *
+ * The engine evaluates `attribute_key` per item exactly as it evaluates the
+ * value, so a key can be a variable, an input, or a filtered expression — and
+ * two rows may carry the SAME key, which a record would silently collapse to
+ * the last one. Reach for the record form whenever the keys are plain literals;
+ * it is what an ordinary object mapping should read like.
+ */
+interface ArrayMapAttribute {
+    /** The key this row contributes, evaluated per item. */
+    key: Value;
+    /** The value stored under it. */
+    value: Value;
+}
+/**
+ * `array.map <source>` — map each element through an expression (`mvp:array_map`).
+ *
+ * Both engine output modes are golden-verified against live captures. The object
+ * path (`output_type:"object"` + `transform_object[]`) stores one
+ * `{attribute_key, attribute_value}` entry per record key, in authored order,
+ * and the key is a plain `const` text triple.
+ *
+ * Only the LIVE branch is emitted, and the capture confirms the engine agrees:
+ * an imported object-mode statement stores NO `transform_value`, and a
+ * value-mode one stores no `transform_object`. The EDITOR is the exception — it
+ * builds its form from the whole context schema and saves every control, so an
+ * editor-saved object-mode statement also carries `transform_value` at its
+ * schema defaults. Both spellings are one state (the engine's object branch
+ * never reads `transform_value`); `liveArrayMapContext` in validate/normalize.ts
+ * is where that equivalence lives, so an editor-authored statement still reads
+ * back to this factory instead of falling to `raw()`.
+ *
+ * ```ts
+ * // scalar: ["a","b"] → ["A","B"]
+ * s.array.map({ source: ref("names"), as: "upper", transform: withFilters(ref("$this"), fl.upper()) })
+ * // object: [1,2] → [{id:1, pos:0}, {id:2, pos:1}]
+ * s.array.map({ source: ref("ids"), as: "rows", transform: { id: ref("$this"), pos: ref("$index") } })
+ * ```
+ */
+declare function arrayMap(a: ArrayMapArgs): Statement;
+interface ArrayUnionArgs extends StatementOptions {
+    /** The base array → stored `left`. */
+    source: Value;
+    /** The array to union in → stored `right`. */
+    with?: Value;
+    as?: string;
+    /** Optional per-item transform → stored `transform_value`. */
+    transform?: Value;
+}
+/**
+ * `array.union <source>` — set-union of arrays (`mvp:array_union`).
+ *
+ * Golden-verified against a live capture: the field remap (source→left,
+ * with→right, transform→transform_value) matches the engine's array-union format.
+ */
+declare function arrayUnion(a: ArrayUnionArgs): Statement;
+/**
+ * `comment` — a no-op annotation node (`mvp:comment`). The text IS this
+ * statement's `description`, so `text` and `a.description` set the same member
+ * and an explicit `a.description` wins; `a.disabled` applies as it does anywhere.
+ */
+declare function comment(text?: string, a?: StatementAnnotations): Statement;
+interface GetRawInputArgs extends StatementOptions {
+    as?: string;
+    /** Body decoding (`json`, `raw`, …). */
+    encoding?: Value;
+    /** Skip middleware-applied transforms. */
+    excludeMiddleware?: Value;
+}
+/**
+ * `util.get_raw_input` / `util.get_input` — capture the raw request body
+ * (`mvp:get_input`). Empty context, and up to two `input[]` entries — `encoding`
+ * (`?=json`) and `exclude_middleware_modification` (note the full stored name;
+ * `?=false`). Both are optional in the engine schema and are written only when
+ * authored, matching what Xano's editor stores.
+ */
+declare function getRawInput(a?: GetRawInputArgs): Statement;
+/**
+ * `util.post_process { … }` — run a post-response sub-stack (`mvp:post_process`).
+ * A pure block statement (engine schema `args: []`): no `as`, just the `run`
+ * stack. Byte-verified (parser-minimal) against the engine's persisted shape.
+ */
+declare function postProcess(body: Statement[], a?: StatementAnnotations): Statement;
+interface RealtimeEventArgs extends StatementAnnotations {
+    /** The channel to publish on. */
+    channel: Value;
+    /** The event payload. */
+    data: Value;
+    /** Optional auth table whose row scopes the event. */
+    authTable?: ObjectRef;
+    /** The auth row id. */
+    authId: Value;
+}
+/**
+ * `api.realtime_event { … }` — publish a realtime event (`mvp:realtime_event`).
+ *
+ * @deprecated Superseded by {@link realtimePublish}. This publishes to Xano's older
+ * workspace-global realtime layer, NOT to a `realtimeChannel()` — its `channel` is a
+ * string against that layer, so pointing it at a current-layer channel path publishes
+ * into the void.
+ *
+ * To originate an event on the current layer, use `s.realtime.publish`, which names the
+ * owning `realtimeServer()` and so addresses a real `realtimeChannel()`.
+ *
+ * Still exported and still supported so `xanots codegen` can bring back a workspace
+ * that holds one. Withheld from the `llms.txt` statement catalog and named only under
+ * `llms/legacy.md`.
+ */
+declare function realtimeEvent(a: RealtimeEventArgs): Statement;
+/**
+ * The realtime server to publish onto: a `realtimeServer()` handle, its bare name, or
+ * a `Value` when the name is computed at runtime.
+ *
+ * The engine resolves this server by NAME within the current workspace and branch —
+ * not by guid — so a handle contributes its `name`, not its identity.
+ */
+type RealtimePublishServer = string | {
+    name: string;
+} | Value;
+interface RealtimePublishArgs extends StatementAnnotations {
+    /**
+     * The owning realtime server, by name. Required: a channel path is unique only
+     * within its server, so the path alone cannot be addressed.
+     */
+    server: RealtimePublishServer;
+    /**
+     * The channel PATH to publish onto, already filled in — `c.text("rooms/42")`, not
+     * the `rooms/{room_id}` template. Build it with `realtimeChannel().getChannel({…})`
+     * rather than concatenating by hand.
+     */
+    channel: Value;
+    /** The event payload delivered to subscribers. */
+    data: Value;
+    /**
+     * Optional message TYPE stamped on the frame, so a client that switches on type can
+     * route a server-originated event the same way it routes a `realtimeMessage()` one.
+     * Naming a type does NOT invoke that message's handler — see the note on delivery below.
+     */
+    message?: Value;
+    /**
+     * Optional ASSERTED identity attributed to the event: name an auth **table** (a
+     * `table({ auth: true })` def or its name) and it resolves to that table's guid.
+     *
+     * This is attribution carried on the frame, NOT a credential — nothing validates it
+     * and no auth gate consumes it. Do not use it to grant a publish that a channel's
+     * `publish.who` would otherwise refuse; this statement bypasses that gate entirely.
+     */
+    authTable?: ObjectRef;
+    /** The asserted identity's row id. Attribution only — see {@link RealtimePublishArgs.authTable}. */
+    authId?: Value;
+}
+/**
+ * `realtime.publish { … }` — originate a server-authored event onto a realtime channel
+ * from any function stack (`mvp:realtime_publish`).
+ *
+ * This is how a query, task, function, or trigger pushes to connected clients without a
+ * client frame arriving first: "the auction closed", "the job finished", "row 42 changed".
+ *
+ * Three properties decide whether this is the right tool, and all three surprise people:
+ *
+ *  - **Delivery-only.** The event is fanned out to subscribers as-is. It does NOT invoke
+ *    a `realtimeMessage()` handler, even when `message` names one, so no stack of yours
+ *    runs on the delivery side. A channel `deliver` trigger still applies (it belongs to
+ *    the channel, not to the message).
+ *  - **Server-authoritative.** It bypasses the channel's `publish.who` policy — that gate
+ *    governs CLIENTS. Any stack that can run this can publish, so guard it in your own
+ *    stack if that matters.
+ *  - **Fail-soft.** A missing or disabled server, a server with no minted canonical, or an
+ *    unreachable bus is logged engine-side and returns quietly. NOTHING throws into your
+ *    stack and there is no return value to check, so a mis-targeted publish is SILENT.
+ *    The two references this SDK can check — `server` and `channel` — throw here at author
+ *    time instead, because that is the only loud failure available.
+ *
+ * It does not rescue `deliverTo: "explicit"` on a `realtimeMessage()`: this originates an
+ * event INTO a channel and never selects recipients from inside a handler.
+ *
+ * ```ts
+ * const rooms = realtimeChannel({ name: "rooms/{room_id}", server: chat, input: { room_id: input.int() } });
+ * s.realtime.publish({
+ *   server: chat,
+ *   channel: c.text(rooms.getChannel({ room_id: 42 })),
+ *   message: c.text("post"),
+ *   data: obj({ body: "the auction closed" }),
+ * });
+ * ```
+ */
+declare function realtimePublish(a: RealtimePublishArgs): Statement;
+interface CreateAuthTokenArgs<As extends string = string> extends StatementOptions {
+    /**
+     * The auth table the token authenticates against.
+     *
+     * `null` is the UNBOUND table the engine stores as a blank guid — deleted, or
+     * never bound. It exists so `codegen` can reproduce such a statement instead
+     * of throwing, the same "no target" spelling `db.query`'s `table` carries.
+     */
+    table: ObjectRef | null;
+    /** Token id (the authenticated row id). */
+    id: Value;
+    /** Extra claims embedded in the token. Defaults to `{}` (no extra claims). */
+    extras?: Value;
+    /** Expiry in seconds. Defaults to `86400` (24h); `0` never expires. */
+    expiration?: Value;
+    as?: As;
+}
+/**
+ * `security.create_auth_token { … }` — mint an auth token (`mvp:create_auth`).
+ *
+ * Branded `AsShapeBrand<As, string>` (like the `db.*` producers) so a
+ * `ref("<as>")` to the minted token traces to `string` via `InferResponse`
+ * instead of `unknown` — the token is always a JWT string. The brand is phantom;
+ * the emitted statement bytes are unchanged.
+ */
+declare function createAuthToken<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(a: CreateAuthTokenArgs<As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<string, Fs>>;
+/**
+ * `security.create_guid` — generate a GUID (`mvp:guid`).
+ *
+ * The engine's statement declares no context, input, or output schema at all
+ * (`Generate GUID`): it takes nothing and binds the generated value, so `as` is
+ * the only thing to author. Sibling of `security.create_uuid` (`mvp:uuid4`),
+ * which is a different generator and a different stored statement — the SDK
+ * models both rather than folding one into the other.
+ *
+ * Branded `AsShapeBrand<As, string>` so a `ref("<as>")` traces to `string`.
+ */
+declare function createGuid<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(a?: {
+    as?: As;
+} & StatementOptions & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<string, Fs>>;
+interface ExpectToThrowArgs extends StatementAnnotations {
+    /** The statements expected to raise. */
+    body: Statement[];
+    /**
+     * Text the raised error's message must CONTAIN (case-insensitive substring).
+     * Omit to accept any error.
+     */
+    exception?: Value;
+}
+/**
+ * `expect.to_throw { … }` — assert a sub-stack throws (`mvp:test_expect_to_throw`).
+ *
+ * The matcher is stored as `context.value1` — the numbered slot every
+ * `expect.*` statement keeps its operands in. It was emitted as
+ * `context.exception` through 2.0.21, a key the engine never reads, so a
+ * to_throw carrying one accepted ANY error instead of the one named (issue #228).
+ */
+declare function expectToThrow(a: ExpectToThrowArgs): Statement;
+interface ExpectToMatchArgs extends StatementAnnotations {
+    /** The value under test — the SUBJECT the pattern is matched against. */
+    expr?: Value;
+    /** The regex PATTERN. Build it with `c.regex(...)`, not `c.text(...)`. */
+    value?: Value;
+}
+/**
+ * `expect.to_match` — assert a value matches a regex (`mvp:test_expect_to_match`).
+ *
+ * A typed, guarded pass-through to the generated factory: same bytes, same
+ * fields. What it adds is the refusal that issue #211 asked for. The `value`
+ * slot is a PHP `preg_*` PATTERN, so a `c.text("^XanoTS.*Engine$")` there is not
+ * a stricter assertion — it is a pattern the engine cannot run, and the test
+ * fails against the very string it was written for:
+ *
+ * ```
+ * to_match failed - regex /"^XanoTS.*Engine$"/ not matched in "XanoTS Automated Testing Engine"
+ * ```
+ *
+ * The refusal is build-time and inspects the value it was handed, exactly as the
+ * `fl.regex_*` guard does (#128): a bare `const` is refused and pointed at
+ * `c.regex`, while a `ref`/`inp`/`env` pattern — whose text is not visible here —
+ * is passed through untouched.
+ */
+declare function expectToMatch(a?: ExpectToMatchArgs): Statement;
+
+/**
+ * Hand-authored typed wrapper for `util.ip_lookup` (#226) — the geolocation
+ * statement whose bound variable is a NESTED object that nothing in the
+ * signature hints at.
+ *
+ * The generated factory types `value` and nothing else, so an author guessing a
+ * flat `{ city, region, latitude, longitude }` gets `null` for every field, and
+ * those nulls fail two steps later with errors that name a column rather than
+ * the lookup. This wrapper delegates encoding to the generated factory (bytes
+ * unchanged) and adds the shape brand, so `ref("geo.location.latitude")` traces
+ * to `number | null` while `ref("geo.latitude")` bottoms out at `unknown`.
+ */
+
+/**
+ * What `util.ip_lookup` binds to its `as` variable: a nested geolocation record,
+ * **not** flat fields. Every leaf is nullable, and `region.*`/`city.name`/
+ * `postal.code` are commonly null even for a well-known routable public address
+ * — a populated `country`/`location` with an empty city is the normal result,
+ * not a failed lookup.
+ *
+ * Read coordinates at `location.latitude`/`location.longitude` and place names
+ * at `city.name`/`region.name`/`country.name`. Note that `city` itself is an
+ * OBJECT: a `ref("geo.city")` written into a text column fails on the object,
+ * and `{ safe: true }` does not help because the object is not null — drill to
+ * `city.name` and supply a fallback.
+ *
+ * The whole variable is `null` when the address cannot be resolved at all
+ * (a private/reserved range, an unroutable or malformed address), so guard the
+ * top level before drilling.
+ */
+interface IpLookupResult {
+    /** Continent code (`"NA"`) and name (`"North America"`). */
+    continent: {
+        code: string | null;
+        name: string | null;
+    };
+    /** ISO-3166 alpha-2 country code (`"US"`) and name (`"United States"`). */
+    country: {
+        code: string | null;
+        name: string | null;
+    };
+    /** Most specific subdivision — state/province. Commonly null. */
+    region: {
+        code: string | null;
+        name: string | null;
+    };
+    /** City name only; there is no city code. Commonly null. */
+    city: {
+        name: string | null;
+    };
+    /** Postal/ZIP code. Commonly null. */
+    postal: {
+        code: string | null;
+    };
+    /** Coordinates, IANA timezone (`"America/Chicago"`), and accuracy radius in KILOMETRES. */
+    location: {
+        latitude: number | null;
+        longitude: number | null;
+        tz: string | null;
+        radius: number | null;
+    };
+}
+interface IpLookupArgs<As extends string = string> extends StatementOptions {
+    /** The IP address to geolocate. */
+    value: Value;
+    /** Bind the nested {@link IpLookupResult} (or `null`) to this stack variable. */
+    as?: As;
+}
+/**
+ * `s.util.ip_lookup({ value, as })` — geolocate an IP address
+ * (`mvp:ipaddress_lookup`).
+ *
+ * Branded `AsShapeBrand<As, IpLookupResult | null>` so `InferResponse` resolves
+ * a dotted `ref` into the real, nested shape instead of `unknown`. The brand is
+ * phantom — the emitted statement is byte-identical to the generated factory's.
+ */
+declare function ipLookup<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(a: IpLookupArgs<As> & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<IpLookupResult | null, Fs>>;
+
+/**
+ * Addon-authoring encoder — the one place that turns an authored {@link AddonSpec}
+ * into the stored `addon[]` block a db statement carries (the shape the engine's
+ * addon import/export walk reads).
+ *
+ * Xano addons graft related-table data onto the rows a `db.query`/`db.get` (and
+ * the other row-returning db ops) return. Each attached addon references a
+ * reusable addon object, maps some of its inputs, optionally restricts its
+ * output columns, and lands its result on the row under a dotted destination
+ * (`offset` + `as`). Addons nest recursively.
+ *
+ * The authoring surface mirrors XanoScript's `addon = [{ name, as, input, output,
+ * addon }]`, with two deliberate divergences:
+ *
+ * - the reference field is named `addon` (an {@link ObjectRef}), so the nesting
+ *   field is named `children` to avoid the collision — which also matches the
+ *   stored/export key (KTD-3);
+ * - the target is a guid-native `ObjectRef`, resolved to a guid and emitted under
+ *   the stored `id` key. In a packageExport bundle the engine matches addons by
+ *   guid (`importAddonId` → `guidMatch`), so emitting the guid as `id` is correct
+ *   — the same precedent `s.addon.call` uses (KTD-1).
+ */
+
+/**
+ * One addon attached to a db statement.
+ *
+ * `as` is the dotted destination on the row (e.g. `"items._book"`); it splits at
+ * the last dot into the stored `offset` (path prefix) + `as` (final segment).
+ * `input` maps addon input names to values — bind parent-row columns with
+ * {@link out} (`{ user_id: out("id") }`). `output` restricts the addon's returned
+ * columns. `children` nests further addons (recursive).
+ */
+interface AddonSpec<Graft = unknown> {
+    /**
+     * The target addon. A typed {@link AddonDef} handle (from {@link addon}) carries
+     * its graft shape into the parent row's response type; a bare name/`ObjectRef`
+     * resolves to a guid but grafts `unknown`.
+     *
+     * `null` is the UNBOUND attachment the engine stores as `id: ""` — an addon
+     * that was deleted or never bound. It exists so `codegen` can reproduce such a
+     * query faithfully instead of throwing and degrading the whole statement to
+     * `raw()`; it grafts `unknown`, which is what an unbound target knows.
+     */
+    addon: ObjectRef | AddonDef<Graft> | null;
+    /**
+     * Dotted destination **relative to a returned row**, e.g. `"_book"` (a bare
+     * alias) or `"obj._book"` (offset + alias). Splits at the last dot into the
+     * stored `offset` (path prefix) + `as` (final segment). Do **not** hand-write
+     * the `items[]` paging-envelope prefix — a `db.query` that returns a metadata
+     * paging envelope adds it automatically (writing it explicitly is tolerated and
+     * not double-prefixed).
+     */
+    as: string;
+    /** Addon input bindings, name → value (use {@link out} for parent-row columns). */
+    input?: Record<string, Value>;
+    /** Restrict the addon's returned columns. Narrows the graft at runtime and in
+     * the grafted type (to `output ∩ the addon's columns`). A dotted entry
+     * (`"img.url"`) selects sub-keys of an object column; the graft narrows by the
+     * root segment, since an object column's sub-keys are not declared. */
+    output?: readonly string[];
+    /** Nested addons (recursive). */
+    children?: AddonSpec[];
+}
+
+/**
+ * Hand-authored database statements (U10) — the `!map:dbo` family: read/delete/
+ * exists/patch/truncate/schema against a table. Codegen defers these because the
+ * target table is a `!map:dbo context.dbo.id` reference; with the guid
+ * foundation (refs/guid.ts) the table resolves to its deterministic guid.
+ *
+ * All six share one rich envelope (engine-class metadata, not in the transform
+ * schema — confirmed against the Xano engine's persisted shape): `description:""`,
+ * `settings_registry:[]`, an `output` block (`{customize:false,filters:[],items:[]}`
+ * by default; a statement with column selection — `db.get`'s `output` arg — emits
+ * `{customize:true, items:[{name,children:[]}]}` per the engine's persisted golden),
+ * `addon:[]`, an always-present `as` (""-default), and `context:{dbo:{id:guid}}`.
+ * Input entries are the rich form `{name,value,tag,filters,ignore,expand,children}`.
+ *
+ * The row-data writes (`db.add`/`db.edit`/`db.add_or_edit`) carry the row as
+ * explicit input entries — one per field, each with an optional `ignore` flag
+ * (system/readonly columns like `id` are stored with `ignore:true`). Authors can
+ * either list the entries exactly (`data: DbField[]`) or pass a *partial* row
+ * (`row: { … }`) and let {@link expandRow} fill it against the table's declared
+ * columns with type defaults + a documented `ignore` heuristic. The latter is a
+ * DX convenience, not a byte-clone of the engine's editor template (see
+ * {@link expandRow} for why that template isn't reproducible — it's a frontend
+ * artifact, and the engine's import path accepts whatever entries it's given).
+ *
+ * Scope: `db.add_or_edit` (extra `context.dbo.as` + inconsistent entries),
+ * `db.bulk*` (array-of-rows), `db.query` (structural !function), and
+ * `db.direct_query`/external SQL/`db.transaction` are deferred.
+ */
+
+/**
+ * The column-name type for a db op's `table` argument: a typed `table()` handle
+ * narrows to its declared columns (+ system columns); a bare name or an untyped
+ * ref falls back to any `string`. Drives schema-aware typing of `fieldName`,
+ * `output`, `sortBy`, and `row` keys.
+ */
+type ColsOf<T> = T extends TableDef<infer C> ? C : string;
+/**
+ * The aliases a query's own `eval` declares — computed columns that exist on the
+ * result but on no table.
+ *
+ * `eval: [{name: "…$searchindex", as: "rank", filters: [{name: "search_rank"}]}]`
+ * makes `rank` selectable and sortable in the SAME call, and the engine's docs
+ * (and this SDK's) say so: each `as` grafts onto the row. Typed only against the
+ * table's columns, `sortBy: "rank"` did not compile — six selections in one real
+ * workspace, all of them valid.
+ */
+type EvalAliases<E> = E extends readonly (infer Item)[] ? Item extends {
+    as: infer A extends string;
+} ? A : never : never;
+/**
+ * The single-row shape a db read yields, for `InferResponse`'s trace (U5): the
+ * table's {@link InferRow}, narrowed to the selected `Cols` when an `output`
+ * list is given, else the full row. A bare-name / raw-`ColumnDef[]` table has no
+ * field brands, so `InferRow` is `never` → `unknown` (nothing to infer).
+ */
+type RowShapeOf<T extends ObjectRef, Cols extends readonly string[]> = [
+    InferRow<T>
+] extends [never] ? unknown : Cols["length"] extends 0 ? InferRow<T> : Pick<InferRow<T>, Extract<OutputRoot<Cols[number]>, keyof InferRow<T>>>;
+/**
+ * The full-row shape a write binds when it carries no column selection —
+ * `db.add_or_edit` (upserted row, which has no `output` envelope at all in its
+ * leaner serialization) and the bulk ops. The whole {@link InferRow}, or
+ * `unknown` for an unbranded bare-name table. Expressed via {@link RowShapeOf}
+ * with an empty `Cols` so the `never`→`unknown` guard is shared with the reads.
+ * (`db.del` is deliberately *not* here — it binds `null`; see {@link dbDel}.)
+ */
+type FullRowShapeOf<T extends ObjectRef> = RowShapeOf<T, readonly []>;
+/**
+ * The alias segment of a dotted addon `as` — the part after the last dot
+ * (`"items._book"` → `"_book"`, `"_book"` → `"_book"`). This is the key the addon
+ * grafts onto the row.
+ */
+type AddonAlias<S extends string> = S extends `${string}.${infer Rest}` ? AddonAlias<Rest> : S;
+/** True only for `unknown` (not `any`, not a concrete type) — guards the graft narrowing below. */
+type IsUnknown<T> = 0 extends 1 & T ? false : unknown extends T ? true : false;
+/**
+ * Narrow a graft `G` to the attachment's `output` column whitelist `O`. The
+ * runtime intersects the def's selected columns with the attachment whitelist
+ * (`whitelistOutput`), so the type picks `O ∩ keyof G`. Applied to the element
+ * of a list graft (`Shape[]`) or a single graft (`Shape`). An `unknown` graft
+ * (bare-name reference, or a def with no typed `output`) stays `unknown` — never
+ * collapse it to `{}`.
+ */
+type NarrowGraft<G, O extends readonly string[]> = IsUnknown<G> extends true ? unknown : G extends readonly (infer E)[] ? Prettify<Pick<E, Extract<OutputRoot<O[number]>, keyof E>>>[] : G extends object ? Prettify<Pick<G, Extract<OutputRoot<O[number]>, keyof G>>> : G;
+/**
+ * The graft shape one attached addon lands on the row. A typed
+ * {@link AddonDef} handle carries its shape (`Pick<row, output>`, an object or
+ * array per its cardinality); a bare name/`ObjectRef` reference carries none, so
+ * it grafts `unknown` — the honest floor (narrow it at the call site). An
+ * attachment-level `output` further restricts the graft to those columns
+ * ({@link NarrowGraft}).
+ */
+type GraftOf<H> = H extends {
+    addon: AddonDef<infer G>;
+} ? H extends {
+    output: infer O extends readonly string[];
+} ? NarrowGraft<G, O> : G : unknown;
+/**
+ * The keys a set of attached addons graft onto each returned row. Each addon's
+ * alias (the last segment of its `as`) becomes a key valued by {@link GraftOf}.
+ *
+ * Mirrors the engine's `applyAddOnSchema` placement — the alias always lands on
+ * the *row element*. With paging the engine wraps rows under `items` (returnAs),
+ * so `as:"items._book"` puts `_book` inside each `items[]` element = each row;
+ * without paging `as:"_book"` puts it on each bare row. Both reduce to "the row
+ * gains the alias key". Nested `children` addons enrich the addon's own result
+ * (under the alias), so they add no parent-visible keys.
+ */
+type AddonFields<A> = A extends readonly [infer H, ...infer Rest] ? (H extends {
+    as: infer S extends string;
+} ? {
+    [K in AddonAlias<S>]: GraftOf<H>;
+} : object) & AddonFields<Rest> : object;
+/**
+ * A row shape augmented with any addon-grafted alias keys. With no addons
+ * (`A = readonly []`) it is the row unchanged, so the non-addon path — and every
+ * existing caller — keeps its exact shape.
+ *
+ * The graft **overrides** any base column of the same name rather than
+ * intersecting with it (`Omit<Row, alias> & AddonFields`): the engine overwrites
+ * the field with the addon result at runtime, so when an alias shadows an
+ * existing column the honest type is the graft (`unknown`), not the base column.
+ * An intersection would collapse `unknown & string` back to the base column and
+ * silently desync the type from runtime (issue #61).
+ */
+type WithAddons<Row, A> = [keyof AddonFields<A>] extends [never] ? Row : Prettify<Omit<Row, keyof AddonFields<A>> & AddonFields<A>>;
+/**
+ * A row shape augmented with any `eval` alias keys. With no evals it is the row
+ * unchanged. Like {@link WithAddons}, an eval alias **overrides** a base column of
+ * the same name (the engine computes over it), so the honest type is the graft.
+ */
+type WithEval<Row, E> = [keyof EvalFields<E>] extends [never] ? Row : Prettify<Omit<Row, keyof EvalFields<E>> & EvalFields<E>>;
+/**
+ * The paging metadata envelope a `db.query` returns when `paging` is set with
+ * metadata on — the engine's `packageListMeta` shape (issue #58). The result
+ * list lives under `items`; `totals:true` adds `itemsTotal`/`pageTotal`. A query
+ * with no `paging`, or `paging:{ metadata:false }`, returns the bare list instead.
+ *
+ * **Has-next signal (issue #66 bonus):** read `nextPage` — it is `number` when
+ * another page exists and `null` on the last page (the engine fetches one extra
+ * row to decide, so this needs no second scan). For a total count, set
+ * `paging:{ totals:true }` and read `itemsTotal`/`pageTotal`. Both are typed on
+ * this envelope by `InferResponse`, so a client can drive "load more" straight
+ * off the typed response without hand-declaring the shape.
+ */
+type PagingEnvelope<Items, Totals extends boolean> = Prettify<{
+    items: Items;
+    itemsReceived: number;
+    curPage: number;
+    nextPage: number | null;
+    prevPage: number | null;
+    offset: number;
+    perPage: number;
+} & (Totals extends true ? {
+    itemsTotal: number;
+    pageTotal: number;
+} : object)>;
+/**
+ * Whether a `paging` arg carries a page/per_page/offset field (static or a
+ * `Value`) — the runtime gate that activates pagination. A `search`/`sort`-only
+ * `paging` has no such field, so it does not produce the envelope.
+ */
+type HasPageFieldT<P> = P extends {
+    page: unknown;
+} ? true : P extends {
+    per_page: unknown;
+} ? true : P extends {
+    offset: unknown;
+} ? true : false;
+/**
+ * Whether a `paging` arg produces the metadata envelope: it activates pagination
+ * (a page/per_page/offset field is present) and is not explicitly `metadata:false`
+ * (the engine default is `metadata:true`).
+ */
+type HasPagingEnvelope<P> = P extends undefined ? false : P extends {
+    metadata: false;
+} ? false : HasPageFieldT<P> extends true ? true : false;
+/** The `totals` flag of a `paging` arg — literal `true` only when set explicitly. */
+type PagingTotals<P> = P extends {
+    totals: true;
+} ? true : false;
+/**
+ * The engine's `context.return.type` for a `db.query` — the return-type
+ * discriminant. `"list"` is the default (a row array or paging envelope);
+ * `"single"` a first-match object; `"count"`/`"exists"` a scalar; `"stream"` a
+ * (pageable) row array with no metadata envelope.
+ */
+type DbReturnType = "list" | "single" | "count" | "exists" | "stream" | "aggregate";
+/** Distinct-row handling (`context.return.<list|stream>.distinct`): engine default `"auto"`. */
+type DbDistinct = "auto" | "yes" | "no";
+/** Aggregate paging (`context.return.aggregate.paging`) — no `offset`/`totals` (engine schema). */
+interface DbAggregatePaging {
+    page?: number;
+    per_page?: number;
+    /** Wrap the result in the metadata envelope (engine default `true`). */
+    metadata?: boolean;
+    /**
+     * The engine's gate. Every field here is read ONLY when this is on, so
+     * `enabled:false` parks a configured block without applying it — the state the
+     * editor leaves behind when pagination is switched back off. Defaults to `true`
+     * (passing `paging` at all is the usual way to ask for it); set `false` only to
+     * reproduce that parked state.
+     */
+    enabled?: boolean;
+}
+/**
+ * Aggregate/group-by config for `returnType:"aggregate"` (`context.return.aggregate`).
+ * `group` are the group-by columns and `eval` the aggregator columns (each
+ * `{ name, as, filters }` — an aggregator like `sum`/`count` rides `filters`).
+ * Both `as` sets graft onto the aggregate row (`unknown` values). Write `name` as
+ * a bare column (`"status"`) — it is alias-qualified to `"<table>.status"` on emit
+ * (the engine requires the qualified form) and the statement declares that alias
+ * so the qualified name resolves; pass an already-dotted `name` for a
+ * `bind`ed/joined column and it is left as-is (and declares nothing, which is
+ * what keeps a pulled workspace byte-exact — see issue #213).
+ */
+interface DbAggregate {
+    group?: DbEval[];
+    eval?: DbEval[];
+    sort?: SortDirective[];
+    paging?: DbAggregatePaging;
+}
+/** A join type for a {@link DbBind} — the engine's `bind[].join`. */
+type DbJoin = "inner" | "left" | "right";
+/**
+ * A db statement's target table — a def handle or name, or `null` for the
+ * engine's own empty binding (`context.dbo.id: ""`).
+ *
+ * ⚠ **Do not author `null`.** It is a BROKEN state in Xano, not a neutral one:
+ * the statement is bound to no table and does nothing wherever it runs. It exists
+ * on these types so `codegen` can represent a broken statement faithfully rather
+ * than degrade the whole thing to `raw()` — a pulled `table: null` is a defect to
+ * fix in the pulled workspace, not a shape to copy.
+ *
+ * It is what a statement degrades to when the table it referenced is deleted, and
+ * also where a freshly-dropped one starts. The engine clears the id rather than
+ * recording a tombstone, so those two are the same bytes: `null` means "unbound",
+ * never "was deleted". The same contract as an addon's `table` (see
+ * {@link addon}), which is where this pattern comes from.
+ *
+ * An unbound table has no schema, so `row:` (which expands the typed row against
+ * the table's columns) is unavailable with it — use `data:`.
+ */
+type DbTableRef<T extends ObjectRef = ObjectRef> = T | null;
+/**
+ * A join (`context.bind[]`): join `table` (aliased by `as`) with `join` kind and
+ * an optional `where` join condition (same search surface as the query). Joins
+ * widen what `where`/`sort`/`eval` can address by dotted path (`"author.id"`);
+ * they do not by themselves change the returned row shape.
+ *
+ * ⚠ **The two sides of a join condition are spelled differently** (issue #213).
+ * The JOINED column takes the dotted alias path; the query's OWN column stays
+ * BARE:
+ *
+ * ```ts
+ * s.db.query({
+ *   table: doc,                                   // columns of `doc` are bare
+ *   bind: [{ table: team, as: "team_row", join: "left",
+ *            where: expr(col("team"), "=", col("team_row.id")) }],
+ * })
+ * ```
+ *
+ * Qualifying your own column with the table's name (`col("doc.team")`) resolves
+ * only when the query also sets {@link DbQueryArgs.tableAlias} — the engine
+ * matches the qualifier against the alias the statement declares, and a query
+ * without `tableAlias` declares none. Unqualified, the engine treats the operand
+ * as a text literal and the request fails with `ParseError: Invalid value for
+ * param:"…"` naming the OTHER operand. Both spellings are checked at export.
+ */
+interface DbBind {
+    /**
+     * The table to join, or `null` when unbound — see {@link DbTableRef} for the
+     * contract, which is the same one the query's own `table` holds. ⚠ Do not
+     * author `null`; it exists so a join whose table was deleted round-trips
+     * instead of taking the whole statement to `raw()`.
+     */
+    table: DbTableRef;
+    /** SQL alias for the joined table — defaults to the table name. Two binds to the same table need distinct aliases. */
+    as?: string;
+    /** Join kind (default `"inner"`). */
+    join?: DbJoin;
+    /** Join condition — same `where`/`cmp`/`and`/`or` surface as the query. */
+    where?: DbWhere;
+}
+/**
+ * The full `db.query` result shape, discriminated by return type `RT`:
+ * `count → number`, `exists → boolean`, `single → row | null`, `stream → row[]`,
+ * and `list → row[]` or the {@link PagingEnvelope} when `paging` requests
+ * metadata. The row is always the addon-augmented row.
+ */
+type QueryResult<Row, A, P, RT extends DbReturnType, E = readonly [], AG = unknown> = RT extends "count" ? number : RT extends "exists" ? boolean : RT extends "aggregate" ? AggregateRow<AG>[] : WithAddons<WithEval<Row, E>, A> extends infer R ? RT extends "single" ? R | null : RT extends "stream" ? R[] : HasPagingEnvelope<P> extends true ? PagingEnvelope<R[], PagingTotals<P>> : R[] : never;
+/**
+ * A db read statement branded — **at the type level only** — via the shared
+ * {@link AsShapeBrand} contract (the stack variable it binds + the shape it
+ * produces). The runtime statement is a plain {@link Statement}, so
+ * `encodeStatement` is unchanged.
+ */
+type DbResult<As extends string, Shape> = Statement & AsShapeBrand<As, Shape>;
+interface DbGetArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[]> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    /** The target table (def handle or name). */
+    table: DbTableRef<T>;
+    /**
+     * The lookup field (defaults to the primary key `id`). A dotted path reaches a
+     * sub-key of an object column (`"google_oauth.id"`) or a joined table's column
+     * — see {@link QualifiedCol}.
+     */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    /** The value to match. */
+    fieldValue: Value;
+    /** Acquire a row lock for the transaction. */
+    lock?: boolean;
+    /**
+     * Restrict the returned columns (XanoScript `output = [...]`). Encoded into
+     * the customized output envelope — `{customize:true, items:[{name,children:[]}]}`
+     * (byte shape per the engine's persisted golden). Omitting it
+     * returns the full record (`customize:false`). Note: an explicit `output`
+     * list overrides column visibility — listing an `internal` column (e.g. a
+     * password hash) pulls it into the statement result. Captured literally so
+     * `InferResponse` narrows a traced row to exactly these columns.
+     */
+    output?: Cols;
+    /** Attach addons to enrich the returned row (see {@link AddonSpec}). Each
+     * addon's alias (the last segment of its `as`) is merged onto the row shape in
+     * `InferResponse` — typed from the addon's graft shape when it's a typed
+     * `addon({ table, output })` handle, or `unknown` for a bare-name reference. */
+    addon?: A;
+    /** Capture the row into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.get <table>` — fetch a single record by a field match (`mvp:dbo_getby`).
+ * Returns a {@link DbResult} branded with `as` + the (optionally narrowed) row
+ * shape **`| null`** so `InferResponse` can type a response that returns this
+ * variable. `dbo_getby` binds **`null` on a miss** (no row matched) rather than
+ * throwing — confirmed live — so the honest shape is `Row | null`, matching
+ * `db.query`'s `returnType:"single"` ({@link QueryResult}). Contrast the row
+ * **writes** (`db.add`/`edit`/`patch`/`add_or_edit`), which bind the full
+ * written row rather than null and so stay non-nullable — a genuine miss throws
+ * instead of yielding null (`NotFound`/404 for `edit`/`patch`; a
+ * unique-constraint error for `add`; `add_or_edit` upserts, so it never misses)
+ * (issue #105). */
+declare function dbGet<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const Fs extends readonly FilterXdo[] = readonly []>(args: DbGetArgs<T, As, Cols, A> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<WithAddons<RowShapeOf<T, Cols>, A> | null, Fs>>;
+interface DbGetByIdArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[]> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    /** The target table (def handle or name). */
+    table: DbTableRef<T>;
+    /** The primary key to fetch. The engine types this `int|min(1)`. */
+    id: Value;
+    /** Restrict the returned columns — same envelope as {@link DbGetArgs.output}. */
+    output?: Cols;
+    /** Attach addons to enrich the returned row (see {@link AddonSpec}). */
+    addon?: A;
+    /** Capture the row into this stack variable. */
+    as?: As;
+}
+/**
+ * `db.get_by_id <table>` — fetch a single record by primary key (`mvp:dbo_get`).
+ *
+ * The narrow sibling of {@link dbGet}: where `db.get` matches any field
+ * (`mvp:dbo_getby`, defaulting to `id`), this one is the engine's dedicated
+ * get-by-primary-key statement and takes a single `id` input. Both are live in
+ * real workspaces — which one the editor wrote is a matter of vintage and which
+ * panel was used — so the SDK models both rather than rewriting one into the
+ * other, which would change the stored bytes.
+ *
+ * Binds `Row | null` for the same reason `db.get` does: a miss yields null
+ * rather than throwing.
+ */
+declare function dbGetById<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const Fs extends readonly FilterXdo[] = readonly []>(args: DbGetByIdArgs<T, As, Cols, A> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<WithAddons<RowShapeOf<T, Cols>, A> | null, Fs>>;
+interface DbDelArgs<T extends ObjectRef = ObjectRef> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef<T>;
+    /** The lookup field. A dotted path reaches an object column's sub-key or a joined table's column ({@link QualifiedCol}). */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    fieldValue: Value;
+    as?: string;
+}
+/**
+ * `db.del <table>` — delete a single record by a field match (`mvp:dbo_delby`);
+ * throws `NotFound`/404 when nothing matches.
+ *
+ * Left **unbranded** (plain {@link Statement}), unlike the other single-record
+ * writes: the engine declares no output schema for this statement and returns
+ * nothing once the row is gone, so the bound `as` variable holds **`null`**, not
+ * the deleted row. `InferResponse` therefore resolves a returned del var to
+ * `unknown` — matching where the engine's own OpenAPI walk falls back to `json`.
+ * (Contrast `db.add`/`edit`/`patch`/`add_or_edit`, which each return the written
+ * row and so bind the full record.)
+ */
+declare function dbDel<T extends ObjectRef>(args: DbDelArgs<T>): Statement;
+interface DbHasArgs<T extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef<T>;
+    /** The lookup field. A dotted path reaches an object column's sub-key or a joined table's column ({@link QualifiedCol}). */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    fieldValue: Value;
+    /** Capture the existence boolean into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.has <table>` — test whether a record exists by a field match (`mvp:dbo_hasby`).
+ * Binds a **boolean** (the engine's `__self: bool` output), so it's branded with
+ * `as` + `boolean` for `InferResponse` — table-independent, unlike the row ops. */
+declare function dbHas<T extends ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: DbHasArgs<T, As> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<boolean, Fs>>;
+interface DbPatchArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[]> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef<T>;
+    /** The lookup field. A dotted path reaches an object column's sub-key or a joined table's column ({@link QualifiedCol}). */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    fieldValue: Value;
+    /** The partial row to merge (an object value). */
+    data: Value;
+    /**
+     * Restrict the columns of the RETURNED row (XanoScript `output = [...]`) —
+     * the confirmation response only; it does not change what is written. Same
+     * customized envelope as {@link DbGetArgs.output}, and offered on exactly the
+     * write ops whose result is a row rather than a scalar: the editor hides the
+     * customize control when a statement's whole output is a single `bool`/`int`
+     * scalar (`db.del`, `db.has`), which is why those take no `output`.
+     */
+    output?: Cols;
+    /** Attach addons to enrich the returned row (see {@link AddonSpec}). Each
+     * addon's alias (the last segment of its `as`) is merged onto the row shape in
+     * `InferResponse` — typed from the addon's graft shape when it's a typed
+     * `addon({ table, output })` handle, or `unknown` for a bare-name reference. */
+    addon?: A;
+    /** Capture the post-patch row into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.patch <table>` — partial-update a record by a field match (`mvp:dbo_patch`).
+ * Binds the **full post-patch row** (`$updatedInst`), so it's branded with `as` +
+ * the row shape for `InferResponse` (throws `NotFound`/404 when nothing matches). */
+declare function dbPatch<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const Fs extends readonly FilterXdo[] = readonly []>(args: DbPatchArgs<T, As, Cols, A> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<WithAddons<RowShapeOf<T, Cols>, A>, Fs>>;
+interface DbTruncateArgs extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef;
+    /** Reset auto-increment counters. */
+    reset?: boolean;
+    as?: string;
+}
+/** `db.truncate <table>` — empty a table (`mvp:dbo_truncate`). */
+declare function dbTruncate(args: DbTruncateArgs): Statement;
+/** One field of a row write: a column name, its value, and whether to skip it. */
+interface DbField {
+    name: string;
+    value: Value;
+    /** Store with `ignore:true` (system/readonly column not written), e.g. `id`. */
+    ignore?: boolean;
+    /**
+     * Sub-entries for an object column: the engine builds the column's value from
+     * these, keyed by each child's name, recursively (stored `expand:true`). The
+     * entry's own `value` is still written — real workspaces carry either an empty
+     * constant or a reference to the object the children were derived from — so it
+     * stays authored rather than derived.
+     */
+    children?: DbField[];
+}
+/**
+ * A row cell: any authored {@link Value} **except** a `col()` reference. A `col()`
+ * (bare or wrapped in `withFilters`) does not resolve to the row's stored value
+ * inside a `db.edit`/`db.add` `row` — it evaluates to `null` at runtime and a
+ * following `fl.add(1)` aborts the engine (issue #32). The `__col?: never` bound
+ * turns that live-only failure into a compile error; read the row first and pipe
+ * `ref("...")` through the filter instead.
+ */
+type RowCell = Value & {
+    readonly __col?: never;
+};
+/**
+ * A nested cell: sub-keys written into an object column, keyed by name. Each
+ * leaf is still a {@link RowCell}, so the `col()` guard above holds at every
+ * depth — nesting adds a level, never an escape hatch.
+ *
+ * The column's own stored value is written as an empty constant, which is what
+ * the overwhelming majority of real expanded entries carry. The one shape this
+ * cannot express is an expanded column whose own value is a reference (the
+ * editor seeds the children from it); author that through `data:` with explicit
+ * `children`, which controls every byte.
+ */
+type NestedCell<C extends string = string> = {
+    readonly [K in C]?: RowCell | NestedCell;
+};
+/** Recover a table handle's inferred row type, falling back to `unknown` for a bare name. */
+type RowsOf<T> = T extends TableDef<string, infer Row> ? Row : unknown;
+/**
+ * A partial row keyed by column name — the values to write. Unspecified columns
+ * get a type default on `db.add`; on `db.edit` they are marked `ignore:true` and
+ * keep their stored value instead (issue #33 — see `expandRow`).
+ *
+ * A cell is a tagged {@link Value}, a {@link NestedCell}, or — since #75 — a bare
+ * JS literal typed against that column ({@link ScalarCell}), which `expandRow`
+ * coerces to the constant the author would otherwise have written by hand.
+ */
+type RowMap<C extends string = string, Row = unknown> = Partial<{
+    [K in C]: RowCell | NestedCell | ScalarCell<K extends keyof Row ? Row[K] : unknown>;
+}>;
+interface DbAddArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[]> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    /**
+     * Refuse to auto-wire request inputs the endpoint did not explicitly bind.
+     *
+     * A row write auto-wires any column whose name matches an incoming request
+     * input, which is convenient and is also how a caller can reach a column the
+     * endpoint never meant to expose. With this on, the engine consults the
+     * endpoint's declared inputs and skips auto-wiring anything outside them;
+     * explicit `data`/`row` entries are unaffected, because those are bindings you
+     * wrote.
+     *
+     * Off by default, matching the engine's own default — so leaving it unset
+     * writes nothing and changes nothing. Reach for it on any write whose table
+     * has a column a caller must not set (`role`, `is_admin`, `credits`).
+     */
+    enforceHiddenFields?: boolean;
+    table: DbTableRef<T>;
+    /** The row to insert as explicit entries (exact control over each field + `ignore`). */
+    data?: DbField[];
+    /** A partial row keyed by column name; expanded against the table's declared columns. */
+    row?: RowMap<ColsOf<T>, RowsOf<T>>;
+    /**
+     * Restrict the columns of the RETURNED row (XanoScript `output = [...]`) —
+     * the confirmation response only; it does not change what is written. Same
+     * customized envelope as {@link DbGetArgs.output}, and offered on exactly the
+     * write ops whose result is a row rather than a scalar: the editor hides the
+     * customize control when a statement's whole output is a single `bool`/`int`
+     * scalar (`db.del`, `db.has`), which is why those take no `output`.
+     */
+    output?: Cols;
+    /** Attach addons to enrich the returned row (see {@link AddonSpec}). Each
+     * addon's alias (the last segment of its `as`) is merged onto the row shape in
+     * `InferResponse` — typed from the addon's graft shape when it's a typed
+     * `addon({ table, output })` handle, or `unknown` for a bare-name reference. */
+    addon?: A;
+    /** Capture the inserted row into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.add <table>` — insert a record (`mvp:dbo_add`). Binds the **full inserted
+ * row** (including the auto-assigned `id`/`created_at`), so it's branded with
+ * `as` + the row shape for `InferResponse`. */
+declare function dbAdd<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const Fs extends readonly FilterXdo[] = readonly []>(args: DbAddArgs<T, As, Cols, A> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<WithAddons<RowShapeOf<T, Cols>, A>, Fs>>;
+interface DbEditArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[]> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    /**
+     * Refuse to auto-wire request inputs the endpoint did not explicitly bind.
+     *
+     * A row write auto-wires any column whose name matches an incoming request
+     * input, which is convenient and is also how a caller can reach a column the
+     * endpoint never meant to expose. With this on, the engine consults the
+     * endpoint's declared inputs and skips auto-wiring anything outside them;
+     * explicit `data`/`row` entries are unaffected, because those are bindings you
+     * wrote.
+     *
+     * Off by default, matching the engine's own default — so leaving it unset
+     * writes nothing and changes nothing. Reach for it on any write whose table
+     * has a column a caller must not set (`role`, `is_admin`, `credits`).
+     */
+    enforceHiddenFields?: boolean;
+    table: DbTableRef<T>;
+    /** The lookup field. A dotted path reaches an object column's sub-key or a joined table's column ({@link QualifiedCol}). */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    fieldValue: Value;
+    /** The new field values as explicit entries (exact control over each field + `ignore`). */
+    data?: DbField[];
+    /**
+     * A **partial** row keyed by column name: only the columns you list are
+     * written. Columns you omit are emitted with `ignore:true` and keep their
+     * stored value — a `{ votes }` edit updates `votes` alone and leaves every
+     * other column intact (issue #33). Expanded against the table's declared
+     * columns. Use `data` for byte-exact control over each entry's `ignore` flag.
+     */
+    row?: RowMap<ColsOf<T>, RowsOf<T>>;
+    /**
+     * Restrict the columns of the RETURNED row (XanoScript `output = [...]`) —
+     * the confirmation response only; it does not change what is written. Same
+     * customized envelope as {@link DbGetArgs.output}, and offered on exactly the
+     * write ops whose result is a row rather than a scalar: the editor hides the
+     * customize control when a statement's whole output is a single `bool`/`int`
+     * scalar (`db.del`, `db.has`), which is why those take no `output`.
+     */
+    output?: Cols;
+    /** Attach addons to enrich the returned row (see {@link AddonSpec}). Each
+     * addon's alias (the last segment of its `as`) is merged onto the row shape in
+     * `InferResponse` — typed from the addon's graft shape when it's a typed
+     * `addon({ table, output })` handle, or `unknown` for a bare-name reference. */
+    addon?: A;
+    /** Capture the post-mutation row into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.edit <table>` — update a record matched by a field (`mvp:dbo_editby`).
+ * Binds the **full post-mutation row** (the freshly-written values), so it's
+ * branded with `as` + the row shape for `InferResponse` (throws `NotFound`/404
+ * when nothing matches). */
+declare function dbEdit<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const Fs extends readonly FilterXdo[] = readonly []>(args: DbEditArgs<T, As, Cols, A> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<WithAddons<RowShapeOf<T, Cols>, A>, Fs>>;
+/**
+ * `db.add_or_edit` (`mvp:dbo_addoreditby`) — upsert: edit the row matched by
+ * `fieldName`/`fieldValue` if it exists, else insert. Its persisted fixture is a
+ * *leaner* serialization generation than the `dbo_add`/`dbo_editby` family:
+ *
+ * - input entries are the lean `{name,value,tag,filters}` form (no
+ *   `expand`/`children`), and only the row `data` entries carry an `ignore`
+ *   flag — the `field_name`/`field_value` lookup pair never do;
+ * - `context.dbo` additionally carries the table's `as` (its name) beside `id`;
+ * - there is no rich `description`/`settings_registry`/`output`/`addon` envelope.
+ *
+ * Matched correct-by-construction against the golden, same posture as the rest
+ * of the db family.
+ */
+interface DbAddOrEditArgs<T extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    /**
+     * Refuse to auto-wire request inputs the endpoint did not explicitly bind.
+     *
+     * A row write auto-wires any column whose name matches an incoming request
+     * input, which is convenient and is also how a caller can reach a column the
+     * endpoint never meant to expose. With this on, the engine consults the
+     * endpoint's declared inputs and skips auto-wiring anything outside them;
+     * explicit `data`/`row` entries are unaffected, because those are bindings you
+     * wrote.
+     *
+     * Off by default, matching the engine's own default — so leaving it unset
+     * writes nothing and changes nothing. Reach for it on any write whose table
+     * has a column a caller must not set (`role`, `is_admin`, `credits`).
+     */
+    enforceHiddenFields?: boolean;
+    table: DbTableRef<T>;
+    /** The match field (defaults to the primary key `id`). */
+    /** The lookup field. A dotted path reaches an object column's sub-key or a joined table's column ({@link QualifiedCol}). */
+    fieldName?: QualifiedCol<ColsOf<T>>;
+    /** The value to match for the edit branch. */
+    fieldValue: Value;
+    /** The row to upsert as explicit entries (exact control over each field + `ignore`). */
+    data?: DbField[];
+    /** A partial row keyed by column name; expanded against the table's declared columns. */
+    row?: RowMap<ColsOf<T>, RowsOf<T>>;
+    /** Capture the upserted row into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+}
+/** `db.add_or_edit <table>` — upsert a record by a field match (`mvp:dbo_addoreditby`).
+ * Binds the **full upserted row** (`$inst->toArray()`, the edit-or-insert result),
+ * so it's branded with `as` + the row shape for `InferResponse`. */
+declare function dbAddOrEdit<T extends ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: DbAddOrEditArgs<T, As> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<FullRowShapeOf<T>, Fs>>;
+interface DbSchemaArgs extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef;
+    /** Dot-path into the schema to read. */
+    path: Value;
+    as?: string;
+}
+/** `db.schema <table>` — read a table's schema (`mvp:dbo_get_schema`). */
+declare function dbSchema(args: DbSchemaArgs): Statement;
+/**
+ * Result shape of a raw-SQL query. The engine schema types this as open
+ * `static:text` (default `"list"`); the known values are suggested while any
+ * string remains accepted.
+ */
+type DbResponseType = "list" | "single" | (string & {});
+/**
+ * How the SQL body is interpolated before it runs.
+ *
+ * `"prepared"` (the engine default) substitutes the positional `args` as bound
+ * parameters. `"template_engine"` renders the body as a template first, which is
+ * what lets a query interpolate structure — a column list, a table name — that a
+ * bound parameter cannot carry. It changes how the statement executes, so it is
+ * authored rather than inferred, and the key is written only when set: the
+ * engine defaults it and omits it at the default.
+ */
+type DbSqlParser = "prepared" | "template_engine";
+interface DbDirectQueryArgs extends StatementOptions {
+    /** The raw SQL to run (stored verbatim as `context.code`). */
+    sql: string;
+    /** Result shape: `"list"` (default) or `"single"`. */
+    responseType?: DbResponseType;
+    /** Positional bind arguments — each a tagged value (filters preserved). */
+    args?: Value[];
+    /** How the SQL body is interpolated. See {@link DbSqlParser}. */
+    parser?: DbSqlParser;
+    /** Capture the result into this stack variable. */
+    as?: string;
+}
+/**
+ * `db.direct_query` (`mvp:dbo_direct_query`) — execute raw SQL against the
+ * workspace database. Unlike the `!map:dbo` family it references no table, so
+ * `context` carries the SQL (`code`), the `response_type`, and the positional
+ * `arg[]` bind values instead of a `dbo.id`. It keeps the same rich envelope.
+ */
+declare function dbDirectQuery(args: DbDirectQueryArgs): Statement;
+interface DbBulkAddArgs extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef;
+    /** The rows to insert (an array value). */
+    items: Value;
+    /**
+     * Honor an explicit `id` on each row (`allow_id_field`).
+     *
+     * ⚠ **Unset/`false` means the engine STRIPS `id` from every item** and assigns
+     * the next sequence value instead — silently, with no error and no warning.
+     * The rows then sit at ids nothing else expects, which surfaces much later as
+     * a foreign key pointing at the wrong row (issue #259).
+     *
+     * This is the opposite of a `table` `seed`, where supplying `id` pins it. If
+     * you are inserting rows whose ids other rows reference, set this to `true`.
+     * Set it to `false` explicitly to state that engine-assigned ids are intended.
+     */
+    allowIdField?: boolean;
+    as?: string;
+}
+/**
+ * `db.bulk.add <table>` — insert many rows (`mvp:dbo_bulkadd`).
+ *
+ * ⚠ An `id` on a row is DISCARDED unless {@link DbBulkAddArgs.allowIdField} is
+ * `true` — see that field. Literal rows carrying one are rejected here rather
+ * than silently renumbered by the engine (issue #259).
+ */
+declare function dbBulkAdd(args: DbBulkAddArgs): Statement;
+interface DbBulkDeleteArgs<As extends string = string> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef;
+    /**
+     * Filter selecting which rows to delete — the same `where` surface as
+     * `s.db.query`: `expr(...)`/`cmp(...)` comparisons, `and(...)`/`or(...)` groups,
+     * an array of those (ANDed), or a raw `Value`. Encoded into `context.search`
+     * via {@link encodeSearch}. **A `where` that constrains nothing deletes every
+     * row in the table**, which is why it requires {@link DbBulkDeleteArgs.allRows}.
+     */
+    where?: DbWhere;
+    /**
+     * Delete EVERY row: the explicit opt-in a `where`-less bulk delete requires.
+     *
+     * A filter-less delete is a truncate, and the shape that reaches it — forgetting
+     * the predicate — looks identical to the shape that meant it. Saying so costs one
+     * word and cannot be typed by accident. Passing both this and a `where` is a
+     * contradiction and throws.
+     *
+     * Emits an EMPTY-GROUP `context.search`, which is what the engine accepts as
+     * "every row" — omitting the key entirely is refused with
+     * `Missing param: search` (XTS-5). Use `s.db.truncate({ reset: true })` when
+     * the id sequence should restart too; this one returns the deleted count.
+     */
+    allRows?: true;
+    /** Capture the deleted-row count into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/**
+ * `db.bulk.delete <table>` — delete many rows by a search (`mvp:dbo_bulkdelete`).
+ * Unlike the other bulk ops, the filter rides `context.search`,
+ * NOT an input entry. The `where` is encoded through the shared {@link encodeSearch}
+ * — the identical operand-based `{expression:[…]}` shape `s.db.query` emits — so the
+ * modern DSL (`expr`/`cmp`/`and`/`or`) is fully supported here too.
+ *
+ * Golden-verified against a live capture: `context.search` (shared with the
+ * `dbo_view` search reader) is byte-exact. A `where` that constrains nothing —
+ * an empty `and()`/`or()` group — deletes all rows and returns the count; the
+ * key itself is mandatory, so `allRows` supplies the empty group (XTS-5).
+ *
+ * Binds the **deleted-row count** (the engine's `__self: int` output), so it's
+ * branded with `as` + `number` for `InferResponse` — table-independent.
+ */
+declare function dbBulkDelete<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: DbBulkDeleteArgs<As> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<number, Fs>>;
+interface DbBulkWriteArgs<T extends ObjectRef = ObjectRef, As extends string = string> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef<T>;
+    /** The rows to write (an array value), each carrying its key. */
+    items: Value;
+    /** Capture the result into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/** `db.bulk.patch <table>` — partial-update many rows (`mvp:dbo_bulkpatch`).
+ * Binds the **patched-row LIST** (the engine's `__self[]` row output), so it's
+ * branded with `as` + the row-list shape for `InferResponse`. */
+declare function dbBulkPatch<T extends ObjectRef, const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(args: DbBulkWriteArgs<T, As> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<FullRowShapeOf<T>[], Fs>>;
+/**
+ * `db.bulk.update <table>` — REPLACE many rows (`mvp:dbo_bulkupdate`).
+ *
+ * ⚠ **Every column an item omits is written to its zero value** (`""` / `0` /
+ * `null` / `[]` / `{}`), not left alone, with an HTTP 200 and no error. This is
+ * a whole-row replace: `{ id: 7, status: "done" }` sets the status and blanks
+ * every other column of row 7. Confirmed in the engine — update and patch run
+ * the same code, and update writes each absent column's default.
+ *
+ * **Use {@link dbBulkPatch} (`s.db.bulk.patch`) to write only the keys an item
+ * carries.** That is what "update these titles" means; this statement is for
+ * replacing rows wholesale. `export()` warns when a STATIC `items` array omits
+ * columns of the bound table, and `--strict` / `export({ strict: true })` fails
+ * the build on it — but an `items` built from a `ref`/`inp` cannot be inspected,
+ * so nothing catches that one for you (issue #15).
+ *
+ * Left **unbranded** (plain {@link Statement}): the engine declares no output
+ * schema for `dbo_bulkupdate`/`dbo_bulkadd`, so
+ * `InferResponse` faithfully resolves a returned bulk-add/update var to `unknown`
+ * — matching where the engine's own OpenAPI walk falls back to `json`. Only
+ * `bulk.patch` (row list) and `bulk.delete` (count) carry a static output schema.
+ */
+declare function dbBulkUpdate(args: DbBulkWriteArgs): Statement;
+/**
+ * Paging controls for `db.query`. Static controls (`page`/`per_page`/`offset` as
+ * plain numbers) land in `context.return.list.paging` (with `enabled:true`) and
+ * mirror the engine schema's `return.list.paging` block: `page=1`, `per_page=25`,
+ * `offset=0`, `totals=false`, `metadata=true`.
+ *
+ * **Input-bound (dynamic) paging (issue #66):** pass a {@link Value} (e.g.
+ * `inp("page")`) for `page`/`per_page`/`offset` instead of a number and it is
+ * emitted into `context.simpleExternal.<field>` as a tagged `{value,tag,filters}`
+ * (byte shape from the `simpleExternal` golden — the inner key is `value`, not
+ * `operand`), while the static block stays as the engine's baseline/fallback and
+ * the gate (`enabled:true`). `search`/`sort` accept a {@link Value} for a
+ * dynamic custom-query / sort override; the engine reads those unconditionally.
+ *
+ * The `enabled:true` gate is keyed on whether a **page/per_page/offset** field is
+ * present (static or `Value`) — a `paging` object carrying *only* `search`/`sort`
+ * leaves `enabled:false`, so a dynamic-search-only override does not silently
+ * activate default pagination and truncate the result to 25 rows.
+ *
+ * Note `metadata:true` (the default) wraps the result in a paging envelope
+ * (`{ items, curPage, nextPage, … }`) rather than returning a bare row list; pass
+ * `metadata:false` to keep the bare array. The envelope only applies when a
+ * page/per_page/offset field is present.
+ */
+interface DbPaging {
+    page?: number | Value;
+    per_page?: number | Value;
+    offset?: number | Value;
+    totals?: boolean;
+    metadata?: boolean;
+    /**
+     * The engine's paging gate (`context.return.<type>.paging.enabled`).
+     *
+     * **Leave this unset.** It defaults to being DERIVED — on whenever a
+     * `page`/`per_page`/`offset` field or a classic `external` blob is present —
+     * which is what stops a `search`/`sort`-only `paging` from silently truncating a
+     * result to 25 rows (issue #41). Setting it overrides that derivation.
+     *
+     * It exists because a stored query can carry the two apart: real workspaces
+     * persist a non-default `per_page` with the gate OFF, and a derived-only encoder
+     * cannot reproduce that — which cost ~158 `db.query` statements their
+     * readability. So this is here to REPRESENT a stored state faithfully, like
+     * `table: null`; authoring `enabled: false` beside a `per_page` asks the engine
+     * to ignore that `per_page`.
+     *
+     * Note it also moves where addons graft: a metadata paging envelope puts rows
+     * under `items[]`, so the gate and the addon offset stay consistent.
+     */
+    enabled?: boolean;
+    /** Dynamic custom-query override (`context.simpleExternal.search`) — a {@link Value}, ANDed onto the static `where`. */
+    search?: Value;
+    /** Dynamic sort override (`context.simpleExternal.sort`) — a {@link Value}; replaces the static sort at runtime. */
+    sort?: Value;
+}
+/**
+ * Which parts of a classic {@link DbExternal} blob the engine is permitted to
+ * honor. Each defaults to the engine's own default (search/sort/page `true`,
+ * `per_page` `false`) — the shape from the `external` golden.
+ */
+interface DbExternalPermissions {
+    search?: boolean;
+    sort?: boolean;
+    page?: boolean;
+    per_page?: boolean;
+}
+/**
+ * The classic single-blob external override (`context.external`). Its resolved
+ * `value` is a whole faceted-filter object (`{search, sort, page, per_page}`),
+ * typically fed from one request input; `permissions` gates which of those
+ * sub-keys the engine honors.
+ *
+ * Combines with input-bound `paging` as a **fallback chain**: the engine uses
+ * this blob when it resolves to something non-empty, and falls back to the
+ * per-field `paging` binds when it does not. Supplying both is a working
+ * configuration — an optional whole-config override in front of per-field
+ * defaults — not a conflict.
+ */
+interface DbExternal {
+    /** The whole external config as one tagged {@link Value} (e.g. `inp("filters")`). */
+    value: Value;
+    /** Per-part gates; each defaults to the engine default. */
+    permissions?: DbExternalPermissions;
+}
+interface DbQueryArgs<T extends ObjectRef = ObjectRef, As extends string = string, Cols extends readonly OutputPath<ColsOf<T> | EvalAliases<E>>[] = readonly ColsOf<T>[], A extends readonly AddonSpec[] = readonly AddonSpec[], P extends DbPaging | undefined = DbPaging | undefined, RT extends DbReturnType = DbReturnType, E extends readonly DbEval[] = readonly DbEval[], AG extends DbAggregate = DbAggregate> extends StatementOptions {
+    /**
+     * SQL alias for the bound table (`context.dbo.as`), used to qualify columns.
+     * Absent unless set — Xano writes it on some statements and not others, so it
+     * is authored rather than derived (see {@link dboBinding}).
+     */
+    tableAlias?: string;
+    table: DbTableRef<T>;
+    /**
+     * The engine's `context.return.type`. `"list"` (default) returns a row array
+     * (or paging envelope); `"single"` a first-match `row | null`; `"count"` a
+     * `number`; `"exists"` a `boolean`; `"stream"` a pageable `row[]` with no
+     * metadata envelope. `InferResponse` reflects each shape.
+     */
+    returnType?: RT;
+    /** Primary filter — `expr(...)`, an array of `expr(...)` (ANDed), or a raw `Value`. */
+    where?: DbWhere;
+    /** Additional filter ANDed with `where` (same forms as `where`). */
+    additionalWhere?: DbWhere;
+    /**
+     * Joins (`context.bind[]`) — `[{ table, as?, join?, where? }]`. Joined columns
+     * are addressable by dotted path in `where`/`sort`/`eval`; the row shape is
+     * unchanged (output columns still come from `output`/`eval`).
+     */
+    bind?: DbBind[];
+    /** Sort directives (`[{ sortBy, dir }]`) — applied by the engine. */
+    sort?: SortDirective<ColsOf<T> | EvalAliases<E>>[];
+    /** Acquire row locks. */
+    lock?: boolean;
+    /**
+     * Paging controls (`page`/`per_page`/`offset`/`totals`/`metadata`) — applied by
+     * the engine. **Supplying `paging` changes the response shape:** with metadata
+     * on (the default) the result is wrapped in a paging envelope
+     * (`{ items, curPage, nextPage, prevPage, offset, perPage, itemsReceived }`,
+     * plus `itemsTotal`/`pageTotal` when `totals:true`) instead of a bare row list,
+     * and `InferResponse` reflects that (issue #58). Pass `metadata:false` to keep
+     * the bare array.
+     */
+    paging?: P;
+    /**
+     * Classic single-blob external override (`context.external`) — one tagged
+     * {@link Value} whose resolved value is a whole `{search,sort,page,per_page}`
+     * config, with per-part `permissions` gates. Mutually exclusive with an
+     * input-bound `paging` field (a `Value` page/per_page/offset/search/sort): the
+     * engine honors `simpleExternal` only when `external` is empty, so authoring
+     * both throws. Setting `external` forces `paging.enabled:true` so its
+     * page/per_page take effect even with no `paging` arg.
+     */
+    external?: DbExternal;
+    /**
+     * Distinct-row handling for a `list`/`stream` query (`"auto"` default | `"yes"`
+     * | `"no"`) → `context.return.<type>.distinct`. Ignored for single/count/exists.
+     */
+    distinct?: DbDistinct;
+    /**
+     * Computed output columns (`context.eval[]`) — each `{ name, as, filters? }`.
+     * The `as` alias grafts onto every returned row as an `unknown`-typed key
+     * (`InferResponse`), since a filter pipeline's output isn't statically knowable.
+     * An alias shadowing an existing column throws at build time.
+     */
+    eval?: E;
+    /**
+     * Aggregate/group-by config, used with `returnType:"aggregate"` →
+     * `context.return.aggregate.{group,eval,sort,paging}`. `InferResponse` types the
+     * aggregate row from the `group` and `eval` aliases (values `unknown`).
+     */
+    aggregate?: AG;
+    /** Restrict returned columns. Captured literally so `InferResponse` narrows
+     * the traced row list to exactly these columns. */
+    output?: Cols;
+    /** Attach addons to enrich each returned row (see {@link AddonSpec}). Each
+     * addon's alias (the last segment of its `as`) is merged onto the row shape in
+     * `InferResponse` as an `unknown`-typed key — narrow it at the call site. Author
+     * `as` relative to a row (`"_user"`); when the query returns a metadata paging
+     * envelope, the `items[]` offset is prefixed automatically. */
+    addon?: A;
+    /** Capture the result list into this stack variable. Captured literally so
+     * `InferResponse` can trace a `ref` back to this statement. */
+    as?: As;
+}
+/**
+ * `db.query <table>` — the query-all search builder (`mvp:dbo_view`). Emits the
+ * context the engine actually reads:
+ * the filter under `context.search` (`{expression:[…]}`, the same operand-based
+ * shape as conditionals/trigger search), sort + paging under
+ * `context.return.list`, and output-column restriction via the statement `output`
+ * envelope. `where`/`sort`/`paging`/`output` are all applied by the engine.
+ *
+ * A comparison `where` (plus `additionalWhere`) encodes into one ANDed
+ * `expression[]`; a raw `Value` is passed through as `context.search`.
+ */
+declare function dbQuery<T extends ObjectRef, const As extends string = "", const Cols extends readonly OutputPath<ColsOf<T> | EvalAliases<E>>[] = readonly [], const A extends readonly AddonSpec[] = readonly [], const P extends DbPaging | undefined = undefined, const RT extends DbReturnType = "list", const E extends readonly DbEval[] = readonly [], const AG extends DbAggregate = DbAggregate, const Fs extends readonly FilterXdo[] = readonly []>(args: DbQueryArgs<T, As, Cols, A, P, RT, E, AG> & {
+    asFilters?: Fs;
+}): DbResult<As, ApplyFilters<QueryResult<RowShapeOf<T, Cols>, A, P, RT, E, AG>, Fs>>;
+interface DbTransactionArgs extends StatementAnnotations {
+    /** The statements to run atomically. */
+    body: Statement[];
+    /**
+     * Capture the transaction's result into this stack variable.
+     *
+     * A transaction returns whatever its sub-stack returned, so the binding is
+     * real state and not decoration — a pulled workspace stores one (issue #147).
+     * The engine's XanoScript schema for this statement declares no `as`
+     * argument, which is why nothing here modelled it; the statement class
+     * returns a value all the same, and the stack item carries the binding like
+     * any other.
+     */
+    as?: string;
+}
+/**
+ * `db.transaction { … }` — run a sub-stack in a database transaction
+ * (`mvp:db_transaction`). Carries the `run` sub-stack and, where the author
+ * bound one, the result variable. Byte-verified (parser-minimal) against the
+ * engine's persisted shape.
+ */
+declare function dbTransaction(args: DbTransactionArgs): Statement;
+/** Supported external-SQL engines for `db.external.<engine>.direct_query`. */
+type ExternalSqlEngine = "mssql" | "mysql" | "oracle" | "postgres" | "snowflake";
+interface DbExternalQueryArgs extends StatementOptions {
+    /** Which external database engine to target. */
+    engine: ExternalSqlEngine;
+    sql: string;
+    /**
+     * How to reach the external database. Prefer `env("NAME")` over a literal.
+     *
+     * A `Value` is stored as the tagged `context.connection_string_flex`, which is
+     * what new work should write. A bare **string** is stored in the older
+     * `context.connection_string` instead — the engine reads it as the name of a
+     * workspace environment variable unless it already looks like a URL, and
+     * falls back to it whenever the tagged value is empty. The two are separate
+     * stored fields, so a workspace holding the older one round-trips as the older
+     * one rather than being quietly rewritten (issue #138).
+     */
+    connectionString: Value | string;
+    responseType?: DbResponseType;
+    args?: Value[];
+    /** How the SQL body is interpolated. See {@link DbSqlParser}. */
+    parser?: DbSqlParser;
+    as?: string;
+}
+/**
+ * `db.external.<engine>.direct_query' — raw SQL against an external database.
+ * Stored shape from the engine's direct-query format (the shared base; these engines extend
+ * it with `connection_string:true`): `context.{code, response_type,
+ * connection_string_flex, arg[]}`. The connection string lands under
+ * `connection_string_flex` (a tagged assignment value), NOT `connection_string`.
+ *
+ * Golden-verified against a live postgres capture: the engine persists
+ * `context.{code,response_type,connection_string_flex,arg}` and does NOT store
+ * `parser` at its default, so the SDK's omission is correct. The rich envelope
+ * matches. @TODO(byte-verify): only postgres captured; the other 4 engines share
+ * the format and stay modeled-by-analogy.
+ */
+declare function dbExternalQuery(args: DbExternalQueryArgs): Statement;
+
+/**
+ * Hand-authored typed wrappers for the HTTP-request statement family — the
+ * "External API Request" (`api.request`) and its siblings `stream.from_request`
+ * and `webflow.request`. Each has a generated bare-`Value`
+ * factory because the codegen source YAML types every field as generic
+ * `!kinds assign`; the engine's *runtime* schema is stricter (method enum, int
+ * timeout, object params, string-array headers, booleans) and the frontend
+ * enforces that shape. These wrappers surface ergonomic, literal-friendly types
+ * (each still accepting a dynamic {@link Value}) and delegate encoding to the
+ * generated factory, so the emitted statement stays byte-identical to the
+ * generated path. Shared coercion + TLS validation live in {@link ./coerce.ts}.
+ *
+ * TLS/mTLS field interdependencies are validated at build time only when the
+ * combination is statically provable-invalid (see `assertSslConsistency`); a
+ * dynamic `Value` is never rejected. `description` (Settings tab) and `output`
+ * (Output tab) ride the envelope where the statement carries one — today only
+ * `api.request` does (its siblings are lean specs).
+ */
+
+/**
+ * The `{request, response}` envelope every external-request statement binds to
+ * its `as` variable (`api.request`, `webflow.request`, `microservice.request`). Shape
+ * confirmed against the Xano engine and a live run: `headers` are
+ * arrays of raw `"Name: value"` lines, `result` is the response body (JSON-decoded
+ * when possible, else the raw string — hence `unknown`), `status` the HTTP code,
+ * and `error` is present only on a transport-level (curl) failure.
+ */
+interface ApiRequestResult {
+    request: {
+        url: string;
+        method: string;
+        headers: string[];
+        params: unknown;
+    };
+    response: {
+        headers: string[];
+        result: unknown;
+        status: number;
+        error?: {
+            code: number;
+            message: string;
+        };
+    };
+}
+interface ApiRequestArgs extends HttpRequestFields, StatementAnnotations {
+    /** Capture the response (`{request, response}`) into this stack variable. */
+    as?: string;
+    /** Request URL. */
+    url?: string | Value;
+    /** Per-statement description (frontend "Settings" tab). */
+    description?: string;
+    /** Output-envelope shaping — result-variable filter chain / field mapping (frontend "Output" tab). */
+    output?: OutputAuthored;
+}
+/**
+ * `api.request` — issue an external HTTP request. Ergonomic, literal-friendly
+ * field types over the generated `mvp:api_request` factory; delegates encoding
+ * to it for byte-parity. Any field also accepts a dynamic {@link Value}.
+ *
+ * `method` suggests the 7 verbs, `params` is a key/value object (→ query string
+ * for GET/HEAD/OPTIONS, body otherwise), `headers` an array of full header-line
+ * strings, `timeout` seconds (engine bounds 1–86400), and the verify/follow
+ * flags booleans.
+ *
+ * A plain-object `params` may carry tagged values (`inp`/`ref`/`c.*`) at the TOP
+ * LEVEL only — each is lifted onto a `const:obj` via a `set` filter. Nest one
+ * inside an object or array and encoding throws, because `const:obj` embeds a
+ * plain JSON constant. For a body with any structure, wrap the whole thing in
+ * `obj({...})`, which encodes any depth as a single `const:expr2`.
+ */
+declare function apiRequest<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(a?: ApiRequestArgs & {
+    as?: As;
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<ApiRequestResult, Fs>>;
+interface StreamFromRequestArgs extends HttpRequestFields, StatementAnnotations {
+    /** Capture the streaming response into this stack variable. */
+    as?: string;
+    /** Request URL. */
+    url?: string | Value;
+}
+/**
+ * `stream.from_request` — stream an external HTTP request (`mvp:streaming_api_request`).
+ * Same typed field surface as {@link apiRequest}; delegates to the generated factory.
+ */
+declare function streamFromRequest(a?: StreamFromRequestArgs): Statement;
+interface WebflowRequestArgs extends HttpRequestFields, StatementAnnotations {
+    /** Capture the response into this stack variable. */
+    as?: string;
+    /** Request path (relative to the Webflow API host). */
+    path?: string | Value;
+}
+/**
+ * `webflow.request` — call the Webflow API (`mvp:connect_webflow_api_request`).
+ * Like {@link apiRequest} but addressed by `path` (the host is engine-supplied).
+ */
+declare function webflowRequest<const As extends string = "", const Fs extends readonly FilterXdo[] = readonly []>(a?: WebflowRequestArgs & {
+    as?: As;
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<ApiRequestResult, Fs>>;
+
+/**
+ * `microservice.request` — call a container workload running alongside the
+ * workspace (`mvp:microservice_request`).
+ *
+ * Its own module rather than a member of the external-HTTP-request family: a
+ * microservice is a first-class workspace object with its own def factory and
+ * its own deploy path, and this statement shares nothing with `api.request`
+ * beyond the `{request, response}` result envelope — no TLS/cert fields, no
+ * `output` envelope, and a different required-field contract (see
+ * {@link MICROSERVICE_DEFAULTS}).
+ *
+ * The bulk of what lives here is host/port resolution: `host` and `port` are an
+ * authoring convenience that folds into the single `"name:port"` string the
+ * engine actually reads, and everything provably wrong about that pairing is
+ * thrown on at build time rather than left to fail at request time.
+ */
+
+/** Host spellings `s.microservice.request` accepts. */
+type MicroserviceHost = MicroserviceDef | string | Value;
+/**
+ * The literal `servicePort`s a def declares, at the type level — the type-side
+ * mirror of {@link declaredServicePorts}.
+ */
+type PortsOf<D> = D extends {
+    deployment: {
+        containers: readonly (infer C)[];
+    };
+} ? C extends {
+    ports: readonly (infer P)[];
+} ? P extends {
+    servicePort: infer S extends string;
+} ? S : never : never : never;
+/** `"8080"` → `8080`, so a port may be written as a number. */
+type AsNumber<S extends string> = S extends `${infer N extends number}` ? N : never;
+/**
+ * What `port` accepts for a given `host`.
+ *
+ * Constrained to the declared ports ONLY when they are known as literals. Two
+ * cases deliberately fall back to the open type rather than narrowing to
+ * `never`, because a false type error on valid code is worse than a missing
+ * one: a def whose ports widened to `string` (annotated `MicroserviceDef`,
+ * built dynamically), and a def that declares no ports at all (helm).
+ */
+type PortArg<D> = string extends PortsOf<D> ? number | string : [PortsOf<D>] extends [never] ? number | string : PortsOf<D> | AsNumber<PortsOf<D>>;
+/**
+ * The five request fields this statement shares with the external-HTTP family,
+ * taken FROM that family's field set rather than restated.
+ *
+ * The two declarations used to be typed byte-for-byte identically in two files,
+ * and the cost showed up the first time one of them widened: the `headers`
+ * record form (issue #72) had to be hand-added in both places, and missing the
+ * second would have left the record spelling silently unavailable here (issue
+ * #92). The per-field docs stay local because the DEFAULTS differ — this
+ * statement's block schema requires all five, so it emits them (see
+ * {@link MICROSERVICE_DEFAULTS}) where `api.request` may leave them out.
+ */
+type HttpFields = Pick<HttpRequestFields, "method" | "params" | "headers" | "timeout" | "follow_location">;
+interface MicroserviceArgs<H extends MicroserviceHost = MicroserviceHost> extends StatementOptions {
+    /** Capture the response into this stack variable. */
+    as?: string;
+    /**
+     * Target microservice — the `microservice()` def to call.
+     *
+     * A plain string is also accepted, and is the only way to reach an
+     * instance-level microservice (those live in instance settings, not the
+     * workspace, so there is no def to pass). It carries its own port:
+     * `"legacy:80"`.
+     */
+    host: H;
+    /**
+     * Port to call, folded into `host` as `name:port`.
+     *
+     * Optional: a microservice declaring exactly one `servicePort` resolves to it.
+     * One declaring several requires this field, and rejects a port it does not
+     * expose — as a TYPE error when the def's ports are known as literals, and as
+     * a build-time throw otherwise. Serialized as text, matching how
+     * `servicePort` is stored.
+     */
+    port?: H extends MicroserviceDef ? PortArg<H> : number | string;
+    /** Request path. */
+    path: string | Value;
+    /** HTTP verb — the 7 engine verbs are suggested; any string or dynamic `Value` is accepted. Defaults to `"GET"`. */
+    method?: HttpFields["method"];
+    /** Request params — a key/value object. Defaults to `{}`. */
+    params?: HttpFields["params"];
+    /** Headers — a `{ Name: value }` record (values may be tagged) or an array of full header-line strings. Defaults to `[]`. */
+    headers?: HttpFields["headers"];
+    /** Request timeout in seconds. Defaults to `10`. */
+    timeout?: HttpFields["timeout"];
+    /** Follow HTTP redirects. Defaults to `true`. */
+    follow_location?: HttpFields["follow_location"];
+}
+/**
+ * `microservice.request` — call an in-cluster microservice
+ * (`mvp:microservice_request`). Typed over the generated factory; no TLS/cert
+ * fields (the engine schema omits them).
+ *
+ * Only `host` and `path` are required. `method`, `params`, `headers`, `timeout`,
+ * and `follow_location` default to the engine's own values
+ * ({@link MICROSERVICE_DEFAULTS}) and are always EMITTED — this statement's
+ * block schema requires them, so they cannot simply be left out:
+ *
+ * ```ts
+ * s.microservice.request({ as: "result", host: echoService, path: "/health" })
+ * ```
+ *
+ * Address it by passing the `microservice()` def itself — its declared ports are
+ * then checked at the authoring site, and a rename fixes every call site at once:
+ *
+ * ```ts
+ * s.microservice.request({ host: echoService, path: "/health", ... })
+ * ```
+ *
+ * `host` binds by NAME, not by guid — deliberately, because the engine resolves
+ * this field by name too (a workspace-scoped lookup on the microservice's name).
+ * A guid here would not be merely unconventional; it would be wrong.
+ */
+declare function microserviceRequest<const As extends string = "", const H extends MicroserviceHost = MicroserviceHost, const Fs extends readonly FilterXdo[] = readonly []>(a: MicroserviceArgs<H> & {
+    as?: As;
+} & {
+    asFilters?: Fs;
+}): Statement & AsShapeBrand<As, ApplyFilters<ApiRequestResult, Fs>>;
+
+/**
+ * Typed `precondition` / `throw` overrides (issue #21).
+ *
+ * `s.throw` raises a generic error the runtime returns with **HTTP 200** and an
+ * error body — a client checking `res.ok` (or any non-2xx guard) treats a
+ * deliberately-thrown error as success. `s.precondition` instead maps its
+ * `error_type` to a status-bearing exception (400/401/403/404/429/…), so a
+ * boundary rejection is observable via standard HTTP semantics.
+ *
+ * Both delegate to the codegen'd factory — the encoded statement is identical —
+ * and only narrow/annotate the authoring types. `error_type` in particular ships
+ * from codegen as a bare `string`; here it becomes the engine's enum so the
+ * valid values (and the status each yields) are discoverable at the call site.
+ */
+
+/**
+ * The exception a failed {@link precondition} raises, and the HTTP status the
+ * runtime returns for it. Mirrors the engine's `mvp:precondition` `error_type`
+ * enum ({@link https://github.com/xanots/sdk/issues/21 #21}):
+ *
+ * - `standard` — generic error (the default).
+ * - `badrequest` — **400** Bad Request.
+ * - `inputerror` — **400** Bad Request, tagged as input validation (the
+ *   `payload` is attached as the offending param).
+ * - `unauthorized` — **401** Unauthorized.
+ * - `accessdenied` — **403** Forbidden.
+ * - `notfound` — **404** Not Found.
+ * - `toomanyrequests` — **429** Too Many Requests.
+ */
+declare const PRECONDITION_ERROR_TYPES: readonly ["standard", "notfound", "toomanyrequests", "accessdenied", "unauthorized", "badrequest", "inputerror"];
+type PreconditionErrorType = (typeof PRECONDITION_ERROR_TYPES)[number];
+interface PreconditionArgs extends StatementAnnotations {
+    /** The condition that must hold. When it evaluates falsy, the error is raised. */
+    expr?: Condition;
+    /**
+     * Which status-bearing exception to raise on failure (default `standard`). Use
+     * e.g. `badrequest` / `inputerror` to reject invalid input with a **400** a
+     * client can detect via `res.ok` — unlike `s.throw`, which returns 200.
+     */
+    error_type?: PreconditionErrorType;
+    /**
+     * The error message. ⚠ **Use `c.text("…")`, not a bare string.**
+     *
+     * The engine reads this field as a TAGGED value and falls back to the generic
+     * `"Precondition failed."` whenever what it reads is empty or non-scalar — so
+     * a bare string is dropped and the client never sees the message you wrote.
+     * A `c.text(...)` (or any computed {@link Value}) is delivered intact. The
+     * `error_type` → HTTP status mapping is correct either way; it is only the
+     * message that is lost.
+     *
+     * The bare-string form stays accepted because a pulled workspace can carry
+     * one and has to round-trip, not because it is a spelling to choose.
+     */
+    error?: Value | string;
+    /** Extra payload attached to the error (for `inputerror`, the offending param). */
+    payload?: Value;
+}
+/**
+ * `precondition { … }` — assert a condition and raise a **status-bearing** error
+ * if it fails (`mvp:precondition`). Prefer this over {@link throwError} (`s.throw`)
+ * whenever the rejection must be observable via HTTP status — a client guarding
+ * on `res.ok` sees a real 4xx instead of a 200 with an error body. See issue #21.
+ *
+ * @example
+ * s.precondition({
+ *   expr: fl.starts_with(input.url, "http"),
+ *   error_type: "badrequest",
+ *   error: c.text("url must start with http:// or https://"),
+ * })
+ */
+declare function precondition(a?: PreconditionArgs): Statement;
+interface ThrowArgs extends StatementAnnotations {
+    /** Optional error name/code. */
+    name?: string;
+    /** The error value/message. */
+    value: Value;
+}
+/**
+ * `throw <value>` — raise an error from the stack (`mvp:throw_error`).
+ *
+ * ⚠️ The runtime returns a thrown error with **HTTP 200** and an error body, so
+ * a client checking `res.ok` treats it as success. For a rejection that surfaces
+ * as a real 4xx status, use {@link precondition} (`s.precondition`) with an
+ * `error_type`. See issue #21.
+ */
+declare function throwError(a: ThrowArgs): Statement;
+
+/**
+ * Typed overrides for statement args the engine declares as a CLOSED SET but the
+ * codegen ships as a bare `string` (issue #65).
+ *
+ * The generated catalog harvests `enum` from the engine's runtime INPUT schemas,
+ * so a closed set declared on a `context`-routed field arrives untyped. Both
+ * fields here are context-routed, which is why they slipped through: the engine
+ * states the members plainly, the SDK's types did not, and a typo type-checked,
+ * exported, and deployed before misbehaving on a live environment.
+ *
+ * `access` is the sharp case. It defaults to `public`, so a misspelled
+ * `"private"` does not fail closed — it serves the file to the world. That is
+ * the wrong direction to fail in, and it was reachable with no compile-time
+ * signal and no documented value list.
+ *
+ * Same shape as {@link ../special/precondition.ts}: delegate to the codegen'd
+ * factory so the encoded statement is byte-identical, and narrow only the
+ * authoring type. The member arrays are exported and consumed by the manifest
+ * renderer (`CONTEXT_FIELD_ENUMS`), so the shipped types and the rendered
+ * catalog line cannot drift from each other.
+ */
+
+/**
+ * Who can read a file created by the `s.storage.create_*` family.
+ *
+ * - `public` — world-readable by URL (**the engine's default**).
+ * - `private` — reachable only through a signed URL
+ *   (`s.storage.sign_private_url`).
+ *
+ * Mirrors the engine's `access` enum on `mvp:create_attachment`,
+ * `mvp:create_audio`, `mvp:create_image` and `mvp:create_video`.
+ */
+declare const STORAGE_ACCESS: readonly ["public", "private"];
+type StorageAccess = (typeof STORAGE_ACCESS)[number];
+/**
+ * What `s.util.set_header` does when the header it sets is already present.
+ *
+ * - `replace` — overwrite the existing value (**the engine's default**).
+ * - `append` — add another value, keeping the existing one.
+ *
+ * Mirrors the engine's `duplicates` enum on `mvp:setheader`.
+ */
+declare const HEADER_DUPLICATES: readonly ["replace", "append"];
+type HeaderDuplicates = (typeof HEADER_DUPLICATES)[number];
+/** `access` narrowed on a generated `storage.create_*` factory. */
+type WithAccess<T> = Omit<T, "access"> & {
+    access?: StorageAccess;
+};
+type CreateAttachmentArgs = WithAccess<Parameters<typeof generated.storage.create_attachment>[0]>;
+type CreateAudioArgs = WithAccess<Parameters<typeof generated.storage.create_audio>[0]>;
+type CreateImageArgs = WithAccess<Parameters<typeof generated.storage.create_image>[0]>;
+type CreateVideoArgs = WithAccess<Parameters<typeof generated.storage.create_video>[0]>;
+type SetHeaderArgs = Omit<Parameters<typeof generated.util.set_header>[0], "duplicates"> & {
+    duplicates?: HeaderDuplicates;
+};
+/**
+ * `create_attachment` — store an uploaded file resource as an attachment.
+ *
+ * ⚠ `access` defaults to `"public"` (world-readable by URL). Pass
+ * `access: "private"` and reach the file through `s.storage.sign_private_url`
+ * when it must not be.
+ */
+declare function createAttachment(a: CreateAttachmentArgs): Statement;
+/**
+ * `create_audio` — store an uploaded file resource as audio metadata.
+ *
+ * ⚠ `access` defaults to `"public"` (world-readable by URL).
+ */
+declare function createAudio(a: CreateAudioArgs): Statement;
+/**
+ * `create_image` — store an uploaded file resource as image metadata.
+ *
+ * ⚠ `access` defaults to `"public"` (world-readable by URL).
+ */
+declare function createImage(a: CreateImageArgs): Statement;
+/**
+ * `create_video` — store an uploaded file resource as video metadata.
+ *
+ * ⚠ `access` defaults to `"public"` (world-readable by URL).
+ */
+declare function createVideo(a: CreateVideoArgs): Statement;
+/**
+ * `set_header` — set a response header. `duplicates` decides what happens when
+ * the header is already present: `replace` (the default) overwrites it,
+ * `append` adds another value alongside it.
+ */
+declare function setHeader(a: SetHeaderArgs): Statement;
+
+/**
+ * Typed refusal of `capture` on `s.lambda` (issue #73).
+ *
+ * The grounding docs introduce an inline `code:` arrow and then, several
+ * paragraphs later, `lam.fn(fn, { surface?, capture? })`. Nothing connected the
+ * two, so `capture` read as a property of lambda bodies generally. The bare
+ * "does not exist in type" error that produced implies the WRONG fix — drop the
+ * field — when the right one is to move the body into `lam.fn`.
+ *
+ * Naming the field and pointing at `lam.fn` costs nothing at runtime: the
+ * factory delegates unchanged, so the encoded statement is byte-identical.
+ */
+
+type LambdaArgs = Parameters<typeof generated.lambda>[0] & {
+    /**
+     * @deprecated Not a field of `s.lambda`. `capture` is an option of `lam.fn` —
+     * move the body there: `code: lam.fn(fn, { capture: { … } })`.
+     *
+     * An inline `code:` arrow receives bindings only, so there is no slot here to
+     * pass data through. Relocate the body; do not drop the field.
+     */
+    capture?: never;
+};
+/**
+ * `lambda { … }` — run a JavaScript body (`mvp:lambda`).
+ *
+ * Delegates to the generated factory unchanged. The only addition is a typed
+ * refusal of `capture` (issue #73): the grounding docs introduce an inline
+ * `code:` arrow and then `lam.fn(fn, { capture })` several paragraphs later, so
+ * `capture` reads as a property of lambda bodies generally. The bare
+ * "does not exist in type" error that produced implies the wrong fix — drop the
+ * field — when the right one is to move the body into `lam.fn`. Naming it here
+ * costs nothing at runtime and puts the answer in the error.
+ */
+declare function lambda(a?: LambdaArgs): Statement;
+
+declare const s: {
+    readonly precondition: typeof precondition;
+    readonly throw: typeof throwError;
+    readonly lambda: typeof lambda;
+    readonly set_var: typeof setVar;
+    readonly update_var: typeof updateVar;
+    readonly conditional: typeof conditional;
+    readonly comment: typeof comment;
+    readonly for: typeof forLoop;
+    readonly foreach: typeof foreachLoop;
+    readonly while: typeof whileLoop;
+    readonly group: typeof group;
+    readonly switch: typeof switchStatement;
+    readonly try_catch: typeof tryCatch;
+    readonly return: typeof returnValue;
+    readonly foreach_break: typeof foreachBreak;
+    readonly foreach_continue: typeof foreachContinue;
+    readonly foreach_remove: typeof foreachRemove;
+    readonly function: {
+        readonly run: typeof functionRun;
+        readonly call: typeof functionCall;
+    };
+    readonly action: {
+        readonly call: typeof actionCall;
+        readonly package: {
+            readonly call: typeof actionPackageCall;
+        };
+    };
+    readonly workflow_test: {
+        readonly call: typeof workflowTestCall;
+    };
+    readonly api: {
+        readonly call: typeof apiCall;
+        readonly realtime_event: typeof realtimeEvent;
+        readonly request: typeof apiRequest;
+        readonly stream: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly microservice: {
+        readonly request: typeof microserviceRequest;
+    };
+    readonly realtime: {
+        readonly publish: typeof realtimePublish;
+        readonly get_session: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly stream: {
+        readonly from_request: typeof streamFromRequest;
+        readonly from_csv: (a: {
+            as?: string;
+            value: Value;
+            separator?: Value;
+            enclosure?: Value;
+            escape_char?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly from_jsonl: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly webflow: {
+        readonly request: typeof webflowRequest;
+    };
+    readonly task: {
+        readonly call: typeof taskCall;
+    };
+    readonly tool: {
+        readonly call: typeof toolCall;
+    };
+    readonly trigger: {
+        readonly call: typeof triggerCall;
+    };
+    readonly middleware: {
+        readonly call: typeof middlewareCall;
+    };
+    readonly addon: {
+        readonly call: typeof addonCall;
+    };
+    readonly db: {
+        readonly add: typeof dbAdd;
+        readonly edit: typeof dbEdit;
+        readonly add_or_edit: typeof dbAddOrEdit;
+        readonly get: typeof dbGet;
+        readonly get_by_id: typeof dbGetById;
+        readonly del: typeof dbDel;
+        readonly has: typeof dbHas;
+        readonly patch: typeof dbPatch;
+        readonly truncate: typeof dbTruncate;
+        readonly schema: typeof dbSchema;
+        readonly direct_query: typeof dbDirectQuery;
+        readonly query: typeof dbQuery;
+        readonly transaction: typeof dbTransaction;
+        readonly bulk: {
+            readonly add: typeof dbBulkAdd;
+            readonly delete: typeof dbBulkDelete;
+            readonly patch: typeof dbBulkPatch;
+            readonly update: typeof dbBulkUpdate;
+        };
+        readonly external: {
+            readonly mssql: {
+                direct_query: (a: Omit<Parameters<typeof dbExternalQuery>[0], "engine">) => Statement;
+            };
+            readonly mysql: {
+                direct_query: (a: Omit<Parameters<typeof dbExternalQuery>[0], "engine">) => Statement;
+            };
+            readonly oracle: {
+                direct_query: (a: Omit<Parameters<typeof dbExternalQuery>[0], "engine">) => Statement;
+            };
+            readonly postgres: {
+                direct_query: (a: Omit<Parameters<typeof dbExternalQuery>[0], "engine">) => Statement;
+            };
+            readonly snowflake: {
+                direct_query: (a: Omit<Parameters<typeof dbExternalQuery>[0], "engine">) => Statement;
+            };
+        };
+        readonly set_datasource: (a: {
+            value: Value;
+            workspace_id?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly ai: {
+        readonly agent: {
+            readonly run: typeof aiAgentRun;
+        };
+        readonly external: {
+            mcp: {
+                server_details: (a?: {
+                    as?: string;
+                    url?: Value;
+                    bearer_token?: Value;
+                    connection_type?: "sse" | "stream" | Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                tool: {
+                    list: (a?: {
+                        as?: string;
+                        url?: Value;
+                        bearer_token?: Value;
+                        connection_type?: "sse" | "stream" | Value;
+                        disabled?: boolean;
+                        description?: string;
+                        asFilters?: FilterXdo[];
+                    }) => Statement;
+                    run: (a?: {
+                        as?: string;
+                        url?: Value;
+                        bearer_token?: Value;
+                        connection_type?: "sse" | "stream" | Value;
+                        tool?: Value;
+                        args?: Value;
+                        disabled?: boolean;
+                        description?: string;
+                        asFilters?: FilterXdo[];
+                    }) => Statement;
+                };
+            };
+        };
+    };
+    readonly cloud: {
+        readonly job: typeof cloudJob & {
+            await: typeof cloudJobAwait;
+            status: typeof cloudJobStatus;
+        };
+        readonly algolia: {
+            request: (a: {
+                as?: string;
+                application_id: Value;
+                api_key: Value;
+                url: Value;
+                method?: "POST" | "GET" | "DELETE" | "PUT" | Value;
+                payload: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+                output?: OutputAuthored;
+            }) => Statement;
+        };
+        readonly aws: {
+            opensearch: {
+                document: (a: {
+                    as?: string;
+                    auth_type?: "IAM" | "master" | Value;
+                    key_id?: Value;
+                    access_key?: Value;
+                    region?: Value;
+                    base_url: Value;
+                    method?: "GET" | "POST" | "PUT" | "DELETE" | Value;
+                    index?: Value;
+                    doc_id?: Value;
+                    doc?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                query: (a?: {
+                    as?: string;
+                    auth_type?: "IAM" | "master" | Value;
+                    key_id?: Value;
+                    access_key?: Value;
+                    region?: Value;
+                    base_url?: Value;
+                    index?: Value;
+                    payload?: Value;
+                    size?: Value;
+                    from?: Value;
+                    included_fields?: Value;
+                    return_type?: "search" | "count" | Value;
+                    expression?: Value;
+                    sort?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                request: (a?: {
+                    as?: string;
+                    auth_type?: "IAM" | "master" | Value;
+                    key_id?: Value;
+                    access_key?: Value;
+                    region?: Value;
+                    method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH" | Value;
+                    url?: Value;
+                    query?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+            };
+            s3: {
+                delete_file: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    file_key: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                get_file_info: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    file_key: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                list_directory: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    prefix?: Value;
+                    next_page_token?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                read_file: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    file_key: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                sign_url: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    file_key: Value;
+                    ttl?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                upload_file: (a: {
+                    as?: string;
+                    bucket: Value;
+                    region: Value;
+                    key: Value;
+                    secret: Value;
+                    file_key?: Value;
+                    file: Value;
+                    metadata?: Value;
+                    object_lock_mode?: "compliance" | "governance" | Value;
+                    object_lock_retain_until?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+            };
+        };
+        readonly azure: {
+            storage: {
+                delete_file: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                get_file_info: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                list_directory: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    path?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                read_file: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                sign_url: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    path: Value;
+                    ttl?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                upload_file: (a: {
+                    as?: string;
+                    account_name: Value;
+                    account_key: Value;
+                    container_name: Value;
+                    filePath: Value;
+                    file: Value;
+                    metadata?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+            };
+        };
+        readonly elasticsearch: {
+            document: (a: {
+                as?: string;
+                auth_type?: "Basic" | "Bearer" | "API Key" | Value;
+                key_id: Value;
+                access_key: Value;
+                base_url: Value;
+                index: Value;
+                method?: "GET" | "POST" | "PUT" | "DELETE" | Value;
+                doc_id: Value;
+                doc: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+            query: (a?: {
+                as?: string;
+                auth_type?: "Basic" | "Bearer" | "API Key" | Value;
+                key_id?: Value;
+                access_key?: Value;
+                base_url?: Value;
+                index?: Value;
+                payload?: Value;
+                size?: Value;
+                from?: Value;
+                included_fields?: Value;
+                return_type?: "search" | "count" | Value;
+                expression?: Value;
+                sort?: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+            request: (a?: {
+                as?: string;
+                auth_type?: "Basic" | "Bearer" | "API Key" | Value;
+                key_id?: Value;
+                access_key?: Value;
+                method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | Value;
+                url?: Value;
+                payload?: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+        };
+        readonly google: {
+            storage: {
+                delete_file: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                get_file_info: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                list_directory: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    path: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                read_file: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    filePath: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                sign_url: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    filePath: Value;
+                    method?: "GET" | "POST" | Value;
+                    ttl?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+                upload_file: (a: {
+                    as?: string;
+                    service_account: Value;
+                    bucket: Value;
+                    filePath: Value;
+                    file: Value;
+                    metadata?: Value;
+                    disabled?: boolean;
+                    description?: string;
+                    asFilters?: FilterXdo[];
+                }) => Statement;
+            };
+        };
+    };
+    readonly array: {
+        readonly map: typeof arrayMap;
+        readonly union: typeof arrayUnion;
+        readonly difference: (a?: {
+            as?: string;
+            expr?: Value;
+            value?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly every: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly filter: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly filter_count: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly find: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly find_index: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly group_by: (a?: {
+            as?: string;
+            expr?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly has: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly intersection: (a?: {
+            as?: string;
+            expr?: Value;
+            value?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly merge: (a?: {
+            name?: string;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly partition: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly pop: (a?: {
+            name?: string;
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly push: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly shift: (a?: {
+            name?: string;
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly unshift: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly expect: {
+        readonly to_throw: typeof expectToThrow;
+        readonly to_match: typeof expectToMatch;
+        readonly to_be_defined: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_empty: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_false: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_greater_than: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_in_the_future: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_in_the_past: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_less_than: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_null: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_true: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_be_within: (a?: {
+            expr?: Value;
+            min?: Value;
+            max?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_contain: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_end_with: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_equal: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_not_be_defined: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_not_be_null: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_not_equal: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly to_start_with: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly security: {
+        readonly create_auth_token: typeof createAuthToken;
+        readonly create_guid: typeof createGuid;
+        readonly check_password: (a?: {
+            as?: string;
+            text_password?: Value;
+            hash_password?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly create_curve_key: (a?: {
+            as?: string;
+            curve?: "P-256" | "P-384" | "P-521" | Value;
+            format?: "object" | "base64" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly create_password: (a?: {
+            as?: string;
+            character_count?: Value;
+            require_lowercase?: Value;
+            require_uppercase?: Value;
+            require_digit?: Value;
+            require_symbol?: Value;
+            symbol_whitelist?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly create_rsa_key: (a?: {
+            as?: string;
+            bits?: Value;
+            format?: "object" | "base64" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly create_secret_key: (a?: {
+            as?: string;
+            bits?: Value;
+            format?: "object" | "base64" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly create_uuid: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly decrypt: (a?: {
+            as?: string;
+            data?: Value;
+            algorithm?: "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc" | "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm" | Value;
+            key?: Value;
+            iv?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly encrypt: (a?: {
+            as?: string;
+            data?: Value;
+            algorithm?: "aes-128-cbc" | "aes-192-cbc" | "aes-256-cbc" | "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm" | Value;
+            key?: Value;
+            iv?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly jwe_decode: (a?: {
+            as?: string;
+            token?: Value;
+            key?: Value;
+            check_claims?: Value;
+            key_algorithm?: "A128KW" | "A192KW" | "A256KW" | "A128GCMKW" | "A192GCMKW" | "A256GCMKW" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW" | Value;
+            content_algorithm?: "A128GCM" | "A192GCM" | "A256GCM" | "A128CBC-HS256" | "A192CBC-HS384" | "A256CBC-HS512" | Value;
+            timeDrift?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly jwe_encode: (a?: {
+            as?: string;
+            headers?: Value;
+            claims?: Value;
+            key?: Value;
+            key_algorithm?: "A128KW" | "A192KW" | "A256KW" | "A128GCMKW" | "A192GCMKW" | "A256GCMKW" | "ECDH-ES+A128KW" | "ECDH-ES+A192KW" | "ECDH-ES+A256KW" | Value;
+            content_algorithm?: "A128GCM" | "A192GCM" | "A256GCM" | "A128CBC-HS256" | "A192CBC-HS384" | "A256CBC-HS512" | Value;
+            ttl?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly jws_decode: (a?: {
+            as?: string;
+            token?: Value;
+            key?: Value;
+            check_claims?: Value;
+            signature_algorithm?: "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512" | "HS256" | "HS384" | "HS512" | "ES256" | "ES384" | "ES512" | Value;
+            timeDrift?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly jws_encode: (a?: {
+            as?: string;
+            headers?: Value;
+            claims?: Value;
+            key?: Value;
+            signature_algorithm?: "PS256" | "PS384" | "PS512" | "RS256" | "RS384" | "RS512" | "HS256" | "HS384" | "HS512" | "ES256" | "ES384" | "ES512" | Value;
+            ttl?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly random_bytes: (a?: {
+            as?: string;
+            length?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly random_number: (a?: {
+            as?: string;
+            min?: Value;
+            max?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly util: {
+        readonly get_raw_input: typeof getRawInput;
+        readonly get_input: typeof getRawInput;
+        readonly post_process: typeof postProcess;
+        readonly ip_lookup: typeof ipLookup;
+        readonly set_header: typeof setHeader;
+        readonly geo_distance: (a?: {
+            as?: string;
+            latitude_1?: Value;
+            longitude_1?: Value;
+            latitude_2?: Value;
+            longitude_2?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly get_all_input: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly get_env: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly get_vars: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly send_email: (a?: {
+            as?: string;
+            service_provider?: "resend" | "xano" | Value;
+            api_key?: Value;
+            subject?: Value;
+            message?: Value;
+            to?: Value;
+            bcc?: Value;
+            cc?: Value;
+            from?: Value;
+            reply_to?: Value;
+            scheduled_at?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly sleep: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        readonly template_engine: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly storage: {
+        readonly create_attachment: typeof createAttachment;
+        readonly create_audio: typeof createAudio;
+        readonly create_image: typeof createImage;
+        readonly create_video: typeof createVideo;
+        readonly create_file_resource: (a: {
+            as?: string;
+            filename: Value;
+            filedata: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly delete_file: (a: {
+            pathname: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        readonly read_file_resource: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        readonly sign_private_url: (a: {
+            as?: string;
+            pathname: Value;
+            ttl?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly await: (a?: {
+        as?: string;
+        ids?: Value;
+        timeout?: Value;
+        disabled?: boolean;
+        description?: string;
+        asFilters?: FilterXdo[];
+    }) => Statement;
+    readonly datadog: {
+        log: (a?: {
+            message?: Value;
+            status?: "debug" | "info" | "notice" | "warn" | "error" | "critical" | "alert" | "emergency" | Value;
+            attributes?: Value;
+            service?: Value;
+            source?: Value;
+            env?: Value;
+            hostname?: Value;
+            tags?: Value;
+            timestamp?: Value;
+            connection?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        log_bulk: (a: {
+            entries: Value;
+            connection?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        metric: (a: {
+            metric?: Value;
+            value: Value;
+            type?: "count" | "gauge" | "rate" | "histogram" | "distribution" | Value;
+            tags?: Value;
+            service?: Value;
+            source?: Value;
+            env?: Value;
+            hostname?: Value;
+            timestamp?: Value;
+            connection?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        metric_bulk: (a: {
+            entries: Value;
+            connection?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly debug: {
+        log: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        stop: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly math: {
+        add: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        bitwise: {
+            and: (a: {
+                name?: string;
+                value: Value;
+                disabled?: boolean;
+                description?: string;
+                output?: OutputAuthored;
+            }) => Statement;
+            or: (a: {
+                name?: string;
+                value: Value;
+                disabled?: boolean;
+                description?: string;
+                output?: OutputAuthored;
+            }) => Statement;
+            xor: (a: {
+                name?: string;
+                value: Value;
+                disabled?: boolean;
+                description?: string;
+                output?: OutputAuthored;
+            }) => Statement;
+        };
+        div: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        mod: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        mul: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        sub: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly object: {
+        entries: (a?: {
+            as?: string;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        keys: (a?: {
+            as?: string;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        values: (a?: {
+            as?: string;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+    };
+    readonly redis: {
+        count: (a: {
+            as?: string;
+            key: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        decr: (a: {
+            as?: string;
+            key: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        del: (a: {
+            key: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        get: (a: {
+            as?: string;
+            key: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        has: (a: {
+            as?: string;
+            key: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        incr: (a: {
+            as?: string;
+            key: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        keys: (a: {
+            as?: string;
+            search: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        pop: (a: {
+            as?: string;
+            key: Value;
+            count?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        push: (a: {
+            as?: string;
+            key: Value;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        range: (a: {
+            as?: string;
+            key: Value;
+            start?: Value;
+            stop?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        ratelimit: (a: {
+            as?: string;
+            key: Value;
+            max?: Value;
+            ttl?: Value;
+            error?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        remove: (a: {
+            as?: string;
+            key: Value;
+            value: Value;
+            count?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        set: (a: {
+            as?: string;
+            key: Value;
+            data: Value;
+            ttl?: Value;
+            create_only?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        shift: (a: {
+            as?: string;
+            key: Value;
+            count?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        unshift: (a: {
+            as?: string;
+            key: Value;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    readonly text: {
+        append: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        contains: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        ends_with: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        icontains: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        iends_with: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        istarts_with: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        ltrim: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        prepend: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        rtrim: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        starts_with: (a: {
+            name?: string;
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        trim: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    readonly zip: {
+        add_to_archive: (a: {
+            file: Value;
+            filename: Value;
+            zip: Value;
+            password?: Value;
+            password_encryption?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        create_archive: (a: {
+            as?: string;
+            filename: Value;
+            password?: Value;
+            password_encryption?: "standard" | "AES-128" | "AES-192" | "AES-256" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        delete_from_archive: (a: {
+            filename: Value;
+            zip: Value;
+            password?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        extract: (a: {
+            as?: string;
+            zip: Value;
+            password?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        view_contents: (a: {
+            as?: string;
+            zip: Value;
+            password?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+};
+
+/**
+ * Wide aliases for the def types that carry generics — the annotation that lets
+ * a workspace be assembled out of independently-authored modules (issue #71).
+ *
+ * The problem is TypeScript's, not the SDK's. `register*` stores defs and does
+ * not read their brands, so it takes them however they arrive. What fails is the
+ * expression that BUILDS the array:
+ *
+ * ```ts
+ * const modules = [catalogModule, chatModule];
+ * workspace("app").registerTables(modules.flatMap((m) => m.tables)); // ✗ TS2322
+ * ```
+ *
+ * `Array.prototype.flatMap` is declared `(cb: (…) => U | ReadonlyArray<U>)`, so
+ * `U` binds to the FIRST element's table type and every later table is checked
+ * against that one table's schema. The diagnostic is ~40 lines of expanded
+ * generics ending in a comparison between two unrelated column names, and it
+ * names neither `flatMap` nor the real cause. `.concat()` collapses the same way.
+ *
+ * Two spellings work. Annotate the module array with the wide alias:
+ *
+ * ```ts
+ * const modules: { tables: readonly AnyTableDef[] }[] = [catalogModule, chatModule];
+ * workspace("app").registerTables(modules.flatMap((m) => [...m.tables])); // ✓
+ * ```
+ *
+ * …or skip the loop and let an array LITERAL infer the union across every
+ * element at once, which is the documented form:
+ *
+ * ```ts
+ * workspace("app").registerTables([...catalogModule.tables, ...chatModule.tables]); // ✓
+ * ```
+ *
+ * Nothing is lost by widening here. The typing an author actually needs lives on
+ * the `table()`/`query()` handle they hold and pass to `s.db.*` — it is never
+ * read back off the registered array.
+ *
+ * Aliases exist for exactly the def types whose generics can collapse this way.
+ * `ApiGroupDef`, `TaskDef`, `TriggerDef`, `MiddlewareDef` and the rest carry no
+ * generics, so a heterogeneous array of them infers cleanly with no annotation.
+ */
+
+/** Any `table()` handle, whatever its schema — see the module note on `flatMap`. */
+type AnyTableDef = TableDef;
+/** Any `query()` handle, whatever its input, stack, response, or name. */
+type AnyQueryDef = QueryHandle;
+/** Any `defineFunction()` def, whatever its input, stack, or response. */
+type AnyFunctionDef = FunctionDef;
+/** Any `addon()` handle, whatever it grafts onto the row. */
+type AnyAddonDef = AddonDef;
+
+/**
+ * `compile()` — façade over the `function` object kind (KTD-2). The envelope
+ * encoding now lives in `src/kinds/function.ts`; this keeps the MVP's public
+ * `compile`/`encodeResponse` surface stable.
+ */
+
+/** Compile a `FunctionDef` into the flattened importable function `xdo`. */
+declare function compile(fn: FunctionDef): FunctionXdo;
+
+/**
+ * An input binding the engine SKIPS.
+ *
+ * A statement's `input[]` entry carries an `ignore` flag. When it is set the
+ * engine records `"<name>:ignore"` and never binds the value at all, so the
+ * parameter falls back to its declared default — which is NOT the same as
+ * passing an empty value, and not the same as omitting the entry (the entry,
+ * with its remembered value, is still stored).
+ *
+ * 1,766 real input entries carry it. The db row-write family already models it
+ * as an `ignore` flag on a `data:` cell; this is the same state for the
+ * spec-routed statements, whose fields are plain {@link Value}s with nowhere to
+ * hang a flag.
+ *
+ * It applies to EVERY spec-routed statement, not only the handful whose stored
+ * envelope spells the entry members out in full — the lean and full input forms
+ * are two serializations of one entry model (issue #16).
+ *
+ * The marker is carried on a non-enumerable property, so it never reaches
+ * `JSON.stringify` and an ignored value serializes exactly like the value it
+ * wraps — the flag is read only by the input encoder, which moves it onto the
+ * entry.
+ */
+
+/**
+ * Mark an input binding as ignored — stored with its value, skipped at runtime.
+ *
+ * Recovery-oriented: `codegen` emits it for a stored `ignore: true` entry so a
+ * pulled workspace reproduces its bytes. Authoring one by hand is legal and
+ * means "keep this parameter's value on record, but do not send it".
+ */
+declare function ignored(value: Value): Value;
+
+export { type ActionCallArgs, type AddonCallArgs, AddonDef, type AddonSpec, type AgentRunResult, type AiAgentRunArgs, type AnyAddonDef, type AnyFunctionDef, type AnyQueryDef, type AnyTableDef, type ApiCallArgs, type ApplyFilter, type ApplyFilters, type ArrayMapArgs, type CloudJobArgs, type CloudJobAwaitArgs, type CloudJobStatusArgs, type CreateAuthTokenArgs, type DbAddArgs, type DbAddOrEditArgs, type DbAggregate, type DbAggregatePaging, type DbBind, type DbBulkAddArgs, type DbBulkDeleteArgs, type DbBulkWriteArgs, type DbDelArgs, type DbDirectQueryArgs, type DbDistinct, type DbEditArgs, DbEval, type DbExternal, type DbExternalPermissions, type DbExternalQueryArgs, type DbField, type DbGetArgs, type DbHasArgs, type DbJoin, type DbPaging, type DbPatchArgs, type DbQueryArgs, type DbResponseType, type DbReturnType, type DbSchemaArgs, type DbTransactionArgs, type DbTruncateArgs, DbWhere, type ExpectToThrowArgs, type ExternalSqlEngine, FilterXdo, FilteredValue, type ForArgs, type ForeachArgs, FromFieldMap, type FunctionCallArgs, FunctionDef, type FunctionRunArgs, FunctionXdo, type GetRawInputArgs, type HeaderMap, type HttpMethod, type InferInput, type InferResponse, InferRow, type IpLookupArgs, type IpLookupResult, MicroserviceDef, type MiddlewareCallArgs, ObjInput, ObjValue, ObjectRef, QueryHandle, type RealtimeEventArgs, RefValue, SortDirective, type StackTupleWidened, Statement, StatementAnnotations, StatementOptions, type SwitchArgs, type SwitchCaseArgs, TableDef, type TaskCallArgs, type ToolCallArgs, type TriggerCallArgs, type TryCatchArgs, Value, type WhileArgs, type WorkflowTestCallArgs, XanoFileRef, actionCall, actionPackageCall, addonCall, aiAgentRun, apiCall, arrayMap, arrayUnion, cloudJob, cloudJobAwait, cloudJobStatus, comment, compile, conditional, createAuthToken, dbAdd, dbAddOrEdit, dbBulkAdd, dbBulkDelete, dbBulkPatch, dbBulkUpdate, dbDel, dbDirectQuery, dbEdit, dbExternalQuery, dbGet, dbHas, dbPatch, dbQuery, dbSchema, dbTransaction, dbTruncate, debugLog, die, expectToThrow, fileUrl, forLoop, foreachBreak, foreachContinue, foreachLoop, foreachRemove, functionCall, functionRun, getRawInput, group, ignored, ipLookup, middlewareCall, postProcess, realtimeEvent, returnValue, s, setVar, switchCase, switchStatement, taskCall, toolCall, triggerCall, tryCatch, updateVar, whileLoop, workflowTestCall };