@xano/sdk 1.0.0

package/dist/store-DuYfzKlW.d.ts

@@ -0,0 +1,3144 @@
+import { V as Value, i as FilterXdo } from './xdo-CxDr2Q1C.js';
+import { t as MockMap, S as Statement } from './response-HlXahv4K.js';
+import { y as Condition, L as LockFile } from './emit-CyhBDxli.js';
+
+/** A surface that takes a JavaScript body: the lambda statement, or a filter. */
+type LambdaSurface = "s.lambda" | "fl.lambda" | "map" | "filter" | "some" | "every" | "find" | "findIndex" | "reduce";
+/**
+ * Surface → the identifiers a body may reference. Live-probed rather than read
+ * off any documentation, and asserted against the recorded probe output in the
+ * tests, so the guard, the types, and the docs cannot disagree with the engine
+ * or with each other.
+ *
+ * `console` and `crypto` are globals inside the body rather than destructured
+ * bindings, so they are legal to reference but are not part of the parameter
+ * type. Every other entry is `$`-prefixed, which is what makes the scan below
+ * able to see a violation at all.
+ */
+declare const LAMBDA_BINDINGS: Readonly<Record<LambdaSurface, readonly string[]>>;
+/** Globals a body may use that are not `$`-bindings (so the scan never sees them). */
+declare const LAMBDA_GLOBALS: readonly string[];
+/**
+ * The libraries the engine preloads as GLOBALS in a lambda body — the only
+ * dependency route that works on every instance.
+ *
+ * A body is prepared for execution in one of two ways depending on the
+ * instance's executor generation, and the two disagree about `import()`:
+ *
+ *   - one transpiles the body and lets the runtime resolve a specifier when the
+ *     `import()` actually runs, so `node:*`, `npm:*`, a bare package and a URL
+ *     all resolve;
+ *   - the other BUNDLES the body before running it, which resolves every
+ *     LITERAL specifier ahead of time against the container's filesystem —
+ *     where none of them exist. `await import("node:crypto")` comes back as the
+ *     text `Could not resolve "node:crypto"`, with HTTP 200. A literal
+ *     `require("axios")` fails there for the same reason.
+ *
+ * These names need no specifier, so they are unaffected by which generation
+ * runs the body. Live-probed from `Object.keys(globalThis)` inside a body; the
+ * evidence is `s.lambda.globalThis` in `vendor/lambda-bindings.json`, and
+ * `test/values/lambda.test.ts` fails if this list drifts from it.
+ *
+ * Not exhaustive by design: it lists what an author is likely to reach for. A
+ * body can always read `Object.keys(globalThis)` for its own instance.
+ */
+declare const LAMBDA_MODULE_GLOBALS: readonly string[];
+/**
+ * Every filter that takes a JavaScript body → which positional slot the body
+ * occupies, and which binding set it runs against.
+ *
+ * The slot is fixed rather than looked up because it is what the guard has to
+ * key on: `filter()` sees positions, not argument names. `reduce`'s body is the
+ * SECOND argument (the accumulator's initial value comes first, and that slot
+ * being invisible is the other half of the same failure); every other lambda
+ * filter's is the
+ * first.
+ *
+ * `fl.transform` is deliberately absent. It takes Xano Expression Engine source,
+ * not a JavaScript body, and binds the operand as `$0` rather than `$this` — so
+ * validating it against THIS contract would reject correct code. It has its own
+ * guard, on its own probed contract, in `./expression-arg.ts`; a
+ * `return` there is not merely refused but sometimes silently mis-evaluated.
+ * `test/values/filters.test.ts` enumerates the `code`-taking filters from
+ * `FILTER_SPECS` and fails if one is missing here.
+ */
+declare const LAMBDA_CODE_FILTERS: Readonly<Record<string, {
+    readonly slot: number;
+    readonly surface: LambdaSurface;
+}>>;
+/**
+ * The statements that take a JavaScript body → the field carrying it and the
+ * bindings it runs against. One today; a table so a second cannot be added
+ * without deciding its surface.
+ */
+declare const LAMBDA_STATEMENTS: Readonly<Record<string, {
+    readonly field: string;
+    readonly surface: LambdaSurface;
+}>>;
+/**
+ * Ambient request state, in scope at every surface.
+ *
+ * Typed `any` deliberately: `$var` holds the enclosing function's stack
+ * variables and `$input` its declared inputs, and threading those inferred
+ * shapes in here is a substantial type-level piece of work in its own right. The
+ * value this parameter carries today is the NAMES — that a binding exists, is
+ * spelled this way, and exists at this surface.
+ */
+interface AmbientBindings {
+    /** Workspace environment variables and request settings. */
+    $env: any;
+    /** The enclosing function's inputs, by name. */
+    $input: any;
+    /** The enclosing function's stack variables, by name — `$var.total`. A stack
+     * variable is NOT also injected as a bare `$total`. */
+    $var: any;
+    /** The authenticated caller, when the request carries a token. */
+    $auth: any;
+}
+/** Ambient state plus the per-element bindings of an iterating filter. */
+interface IteratingBindings extends AmbientBindings {
+    /** The current element. */
+    $this: any;
+    /** The current element's position, from 0. */
+    $index: number;
+    /** The whole array the filter is applied to. */
+    $parent: any;
+}
+/** The bindings in scope in a body at `S` — the type of a {@link lam.fn} parameter. */
+type LambdaBindings<S extends LambdaSurface = "reduce"> = S extends "reduce" ? IteratingBindings & {
+    /** The accumulator. Commonly mis-typed as `$acc`. */
+    $result: any;
+} : S extends "s.lambda" ? AmbientBindings : S extends "fl.lambda" ? AmbientBindings & {
+    /** The piped value the filter is applied to. */
+    $this: any;
+} : IteratingBindings;
+/**
+ * A lambda body written INLINE at the call site, where the surface is already
+ * known — `fl.map(({ $this }) => $this * 2)`.
+ *
+ * This is the form to reach for. `lam.fn` exists for a body that is shared,
+ * captured, or otherwise built away from where it runs; everywhere else the
+ * call site knows which surface it is, so naming the surface a second time is
+ * something for the SDK to do rather than the author. TypeScript types the
+ * parameter contextually from the position, so `$this` autocompletes inside
+ * `fl.map` and `$result` does not compile there.
+ */
+type LambdaBody<S extends LambdaSurface = LambdaSurface> = (bindings: LambdaBindings<S>, captured: Record<string, CaptureValue>) => unknown;
+/** A JSON value a capture entry can carry into the body. */
+type CaptureValue = string | number | boolean | null | {
+    [k: string]: CaptureValue;
+} | CaptureValue[];
+/**
+ * The CHECKING form of {@link CaptureValue}, used wherever a capture is
+ * constrained rather than described.
+ *
+ * `CaptureValue` names the shape for a reader, but it cannot be a constraint on
+ * its own: its object arm is an index signature, and TypeScript hands an
+ * implicit index signature to type ALIASES only — never to an `interface`, which
+ * stays open to declaration merging. So `capture: { band }` compiled when `band`
+ * was a `type` and failed when the identical shape was an `interface`, with the
+ * error naming `CaptureValue` rather than the one keyword that differed, and the
+ * body's second parameter then degrading to the constraint.
+ *
+ * A homomorphic mapped type is the way through: `keyof` an interface is the same
+ * as `keyof` the alias, so this accepts both and still rejects what genuinely
+ * cannot cross the boundary as text — functions, `undefined`, `symbol`, `bigint`
+ * — matching the runtime check in {@link capturePrelude}.
+ */
+type Capturable<T> = T extends string | number | boolean | null ? T : T extends (...args: never[]) => unknown ? never : T extends readonly (infer U)[] ? readonly Capturable<U>[] : T extends object ? {
+    [K in keyof T]: Capturable<T[K]>;
+} : never;
+/** A capture bag: every value {@link Capturable}, whatever it was declared as. */
+type CaptureRecord<T> = {
+    [K in keyof T]: Capturable<T[K]>;
+};
+/** Options shared by every `lam.*` form. */
+interface LambdaOptions<C = Record<string, never>> {
+    /**
+     * Which surface the body will run at, which is what decides the legal
+     * bindings.
+     *
+     * Omit it and the check is DEFERRED to the call site, which knows the answer:
+     * dropping the body into `fl.map(...)` or `s.lambda({...})` validates it there,
+     * against that surface. Naming it here is for a body built away from its call
+     * site — a shared constant, or one that should fail at its own definition
+     * rather than at its use.
+     *
+     * Better still, write the body inline (`fl.map(({ $this }) => …)`), where the
+     * surface is implied and TypeScript types the bindings from the position.
+     */
+    surface?: LambdaSurface;
+    /**
+     * Values from the enclosing TypeScript scope to carry into the body, emitted
+     * as a `const` prelude.
+     *
+     * Nothing crosses the boundary implicitly: the body is extracted as TEXT and
+     * runs in a different process, so a closed-over `const rate` is simply
+     * undefined at runtime. Rather than guess at free variables (which needs a
+     * JavaScript parser this package deliberately does not have), capture is
+     * explicit and the second parameter of the body destructures it.
+     */
+    capture?: C;
+}
+/**
+ * Reject a body that cannot work at `surface`, before it can reach a live
+ * request. Three failures are unwritable after this:
+ *
+ * 1. an `$identifier` outside the surface's binding set — provably undefined at
+ *    runtime, because a stack variable is only ever reachable as `$var.name`;
+ * 2. a top-level `import`/`export`, which is a syntax error in a function body
+ *    (a dependency comes from {@link LAMBDA_MODULE_GLOBALS}, which needs no
+ *    specifier — see there for why a literal `import()` one is not portable);
+ * 3. an empty body, which stores a statement the engine refuses at import.
+ *
+ * Exported so the statement and filter factories can run the same check on a
+ * plain `c.text(...)` body — an author who never adopts `lam.*` gets the same
+ * answer at the same moment.
+ */
+declare function assertLambdaBody(body: string, surface: LambdaSurface, source?: string): void;
+/**
+ * Author a lambda body as a typed TypeScript function.
+ *
+ * The first parameter destructures the bindings for the surface, so the editor
+ * supplies them and a wrong name is a compile error rather than a wrong value at
+ * runtime. The body is extracted at author time and emitted as the same
+ * `const:text` a hand-written `c.text(...)` produced.
+ *
+ * ```ts
+ * lam.fn(({ $result, $this }) => $result + $this)                 // reduce
+ * lam.fn(({ $var }) => $var.subtotal * 1.2, { surface: "s.lambda" })
+ * lam.fn(({ $this }, { capturedRate }) => $this * capturedRate, { surface: "map", capture: { capturedRate: rate } })
+ * ```
+ *
+ * Nothing from the enclosing scope crosses implicitly — a closed-over value is
+ * undefined at runtime — so anything the body needs from outside goes in
+ * `capture` and arrives as the second parameter. Give the capture a key nothing
+ * at module scope shares (it need not keep the name of what it carries); a
+ * collision is refused at build time, because the loader renames one of the two
+ * and the prelude is written under the original name.
+ */
+declare function fn<S extends LambdaSurface = "reduce", C extends CaptureRecord<C> = Record<string, never>>(body: (bindings: LambdaBindings<S>, captured: C) => unknown, opts?: LambdaOptions<C> & {
+    surface?: S;
+}): Value;
+/**
+ * The escape hatch: a lambda body as text, validated exactly like {@link fn}.
+ *
+ * For a body that genuinely cannot be an authored function — one assembled at
+ * build time, or lifted verbatim out of a pulled workspace. It is guarded, not
+ * extracted, so the guard cannot be sidestepped by choosing this form.
+ */
+declare function raw(code: string, opts?: LambdaOptions<Record<string, CaptureValue>>): Value;
+/**
+ * Lambda authoring. `lam.fn` for an inline typed body, `lam.raw` for text, and
+ * `lam.file` (from `@xano/sdk/node`) for a body big enough to want its own
+ * type-checked module. All three produce the same `const:text` {@link Value} and
+ * pass the same validation.
+ *
+ * `file` is deliberately absent from the TYPE here so `lam.file` off this entry
+ * is a compile error that names the Node entry; the runtime stub only catches
+ * the calls types didn't.
+ */
+declare const lam: {
+    fn: typeof fn;
+    raw: typeof raw;
+};
+
+/** A bare JS literal a filter argument accepts in place of a {@link Value}. */
+type Scalar = string | number | boolean;
+/**
+ * Marker for a filter declared `<T>` — it returns the ELEMENT of the array it
+ * is given (`first`, `last`, `array_pop`). Never a value; only a fold signal.
+ */
+interface ElementResult {
+    readonly __result: "element";
+}
+/**
+ * Marker for a filter declared `<T>[]` — it returns an array of the same
+ * element type it was given (`reverse`, `unique`, `array_slice`).
+ */
+interface SameArrayResult {
+    readonly __result: "sameArray";
+}
+/**
+ * Marker for a GROUP-BY — an object keyed by the argument path whose every
+ * value is an ARRAY of the elements it was given (`index_by`). A single
+ * matching item still arrives wrapped in a one-element array, so a lookup reads
+ * `idx[key][0]`.
+ */
+interface GroupedArrayResult {
+    readonly __result: "groupedArray";
+}
+/** Every filter name applicable to a value pipeline (authoritative membership). */
+declare const FILTER_NAMES: readonly string[];
+/**
+ * Each filter's RESULT type, at the type level.
+ *
+ * Generated from the same `result` the specs above carry, so the two cannot
+ * drift. Three entries are markers rather than concrete types, mirroring the
+ * generic results the catalog declares:
+ *
+ *   - {@link ElementResult} (`<T>`)   — the ELEMENT of the array it is given
+ *     (`first`, `last`, `array_pop`, …)
+ *   - {@link SameArrayResult} (`<T>[]`) — an array of the same element type
+ *     (`reverse`, `unique`, `array_slice`, …)
+ *   - {@link GroupedArrayResult} (`{ [key: string]: <T>[] }`) — a group-by
+ *     keyed by the argument path (`index_by`)
+ *
+ * A filter whose result is `any` — or one upstream declares nothing for — is
+ * absent from this map and folds to `unknown`. That is deliberate: `get`,
+ * `set`, `transform`, and `json_decode` genuinely produce a shape no
+ * declaration could name, and a confident wrong type is worse than an honest
+ * `unknown`.
+ *
+ * Verified against a live engine rather than trusted (`_probe-filter-results`):
+ * one filter per declared category was executed and its actual JSON type
+ * compared with the declaration.
+ */
+interface FilterResults {
+    "abs": number;
+    "acos": number;
+    "acosh": number;
+    "add": number;
+    "addslashes": string;
+    "append": SameArrayResult;
+    "array_diff": SameArrayResult;
+    "array_diff_assoc": SameArrayResult;
+    "array_filter": SameArrayResult;
+    "array_find": ElementResult;
+    "array_has": boolean;
+    "array_intersect": SameArrayResult;
+    "array_intersect_assoc": SameArrayResult;
+    "array_keys": string[];
+    "array_lower": SameArrayResult;
+    "array_merge": SameArrayResult;
+    "array_merge_recursive": SameArrayResult;
+    "array_pop": ElementResult;
+    "array_push": SameArrayResult;
+    "array_push_conditional": SameArrayResult;
+    "array_remove": SameArrayResult;
+    "array_replace": SameArrayResult;
+    "array_set": Record<string, unknown>;
+    "array_shift": ElementResult;
+    "array_shuffle": SameArrayResult;
+    "array_slice": SameArrayResult;
+    "array_unshift": SameArrayResult;
+    "array_upmerge": SameArrayResult;
+    "asin": number;
+    "asinh": number;
+    "atan": number;
+    "atanh": number;
+    "avg": number;
+    "base64_decode": string;
+    "base64_decode_urlsafe": string;
+    "base64_encode": string;
+    "base64_encode_urlsafe": string;
+    "base_convert": string;
+    "bin2hex": string;
+    "bindec": string;
+    "bitwise_and": number;
+    "bitwise_not": boolean;
+    "bitwise_or": number;
+    "bitwise_xor": number;
+    "capitalize": string;
+    "ceil": number;
+    "clamp_max": number;
+    "clamp_min": number;
+    "concat": string;
+    "contains": boolean;
+    "convert_encoding": string;
+    "cos": number;
+    "count": number;
+    "crypto_jwe_encode": string;
+    "crypto_jws_encode": string;
+    "csv_create": string;
+    "csv_encode": string;
+    "decbin": string;
+    "dechex": string;
+    "decoct": string;
+    "decrypt": string;
+    "deg2rad": number;
+    "detect_encoding": string;
+    "div": number;
+    "empty": boolean;
+    "encrypt": string;
+    "ends_with": boolean;
+    "epochms_add_ms": number;
+    "epochms_add_secs": number;
+    "epochms_date": string;
+    "epochms_from_format": string;
+    "epochms_transform": string;
+    "eq": boolean;
+    "escape": string;
+    "even": boolean;
+    "exp": number;
+    "filter_empty": SameArrayResult;
+    "filter_empty_array": SameArrayResult;
+    "filter_empty_object": SameArrayResult;
+    "filter_empty_text": SameArrayResult;
+    "filter_false": SameArrayResult;
+    "filter_null": SameArrayResult;
+    "filter_zero": SameArrayResult;
+    "first": ElementResult;
+    "flatten": SameArrayResult;
+    "floor": number;
+    "from_utf8": string;
+    "fsort": SameArrayResult;
+    "gt": boolean;
+    "gte": boolean;
+    "has": boolean;
+    "hex2bin": string;
+    "hexdec": string;
+    "hmac_md5": string;
+    "hmac_sha1": string;
+    "hmac_sha256": string;
+    "hmac_sha384": string;
+    "hmac_sha512": string;
+    "icontains": boolean;
+    "iends_with": boolean;
+    "in": boolean;
+    "index_by": GroupedArrayResult;
+    "is_array": boolean;
+    "is_bool": boolean;
+    "is_decimal": boolean;
+    "is_int": boolean;
+    "is_object": boolean;
+    "is_text": boolean;
+    "is_uuid": boolean;
+    "istarts_with": boolean;
+    "join": string;
+    "json_encode": string;
+    "last": ElementResult;
+    "list_encodings": string[];
+    "ln": number;
+    "log": number;
+    "log10": number;
+    "lower": string;
+    "lt": boolean;
+    "lte": boolean;
+    "ltrim": string;
+    "max": number;
+    "md5": string;
+    "min": number;
+    "mod": number;
+    "ms_to_secs": number;
+    "mul": number;
+    "ne": boolean;
+    "not": boolean;
+    "num_max": number;
+    "num_min": number;
+    "number_format": string;
+    "octdec": string;
+    "odd": boolean;
+    "pick": ElementResult;
+    "pow": number;
+    "prepend": SameArrayResult;
+    "product": number;
+    "rad2deg": number;
+    "range": number[];
+    "regex_match": string[];
+    "regex_match_all": string[];
+    "regex_quote": string;
+    "regex_replace": string;
+    "regex_test": boolean;
+    "reverse": SameArrayResult;
+    "round": number;
+    "rsort": SameArrayResult;
+    "rtrim": string;
+    "safe_array": SameArrayResult;
+    "secs_to_ms": number;
+    "secureid_decode": number;
+    "secureid_encode": string;
+    "sha1": string;
+    "sha256": string;
+    "sha384": string;
+    "sha512": string;
+    "sin": number;
+    "splice": SameArrayResult;
+    "split": string[];
+    "sprintf": string;
+    "sql_alias": string;
+    "sql_esc": string;
+    "sqrt": number;
+    "starts_with": boolean;
+    "string_replace": string;
+    "strip_accents": string;
+    "strip_tags": string;
+    "stripos": number;
+    "strlen": number;
+    "strpos": number;
+    "sub": number;
+    "substr": string;
+    "sum": number;
+    "tan": number;
+    "text_escape": string;
+    "text_unescape": string;
+    "to_bool": boolean;
+    "to_decimal": number;
+    "to_epoch_day": number;
+    "to_epoch_hour": number;
+    "to_epoch_minute": number;
+    "to_epoch_ms": number;
+    "to_epoch_sec": number;
+    "to_epochms": number;
+    "to_geo_linestring": string;
+    "to_geo_multilinestring": string;
+    "to_geo_multipoint": string;
+    "to_geo_multipolygon": string;
+    "to_geo_point": string;
+    "to_geo_polygon": string;
+    "to_int": number;
+    "to_text": string;
+    "to_utf8": string;
+    "trim": string;
+    "uid": number;
+    "unique": SameArrayResult;
+    "unpick": ElementResult;
+    "upper": string;
+    "url_addarg": string;
+    "url_decode": string;
+    "url_decode_rfc3986": string;
+    "url_delarg": string;
+    "url_encode": string;
+    "url_encode_rfc3986": string;
+    "url_getarg": string;
+    "url_hasarg": string;
+    "uuid4": string;
+    "yaml_decode": Record<string, unknown>;
+    "yaml_encode": string;
+}
+/** Typed, discoverable constructors for the value `filters[]` pipeline. */
+declare const fl: {
+    readonly abs: () => FilterXdo<"abs">;
+    readonly acos: () => FilterXdo<"acos">;
+    readonly acosh: () => FilterXdo<"acosh">;
+    readonly add: (((value: Scalar | Value) => FilterXdo<"add">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"add">));
+    readonly addslashes: () => FilterXdo<"addslashes">;
+    readonly append: (((value: Scalar | Value, path: Scalar | Value) => FilterXdo<"append">) & ((args: {
+        value: Scalar | Value;
+        path: Scalar | Value;
+    }) => FilterXdo<"append">));
+    readonly array_diff: (((value: Scalar | Value) => FilterXdo<"array_diff">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_diff">));
+    readonly array_diff_assoc: (((value: Scalar | Value) => FilterXdo<"array_diff_assoc">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_diff_assoc">));
+    readonly array_entries: () => FilterXdo<"array_entries">;
+    readonly array_fill: (((start: Scalar | Value, count: Scalar | Value) => FilterXdo<"array_fill">) & ((args: {
+        start: Scalar | Value;
+        count: Scalar | Value;
+    }) => FilterXdo<"array_fill">));
+    readonly array_fill_keys: (((keys: Scalar | Value) => FilterXdo<"array_fill_keys">) & ((args: {
+        keys: Scalar | Value;
+    }) => FilterXdo<"array_fill_keys">));
+    readonly array_filter: (((match: Scalar | Value, path?: Scalar | Value) => FilterXdo<"array_filter">) & ((args: {
+        match: Scalar | Value;
+        path?: Scalar | Value;
+    }) => FilterXdo<"array_filter">));
+    readonly array_find: (((match: Scalar | Value) => FilterXdo<"array_find">) & ((args: {
+        match: Scalar | Value;
+    }) => FilterXdo<"array_find">));
+    readonly array_has: (((match: Scalar | Value) => FilterXdo<"array_has">) & ((args: {
+        match: Scalar | Value;
+    }) => FilterXdo<"array_has">));
+    readonly array_intersect: (((value: Scalar | Value) => FilterXdo<"array_intersect">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_intersect">));
+    readonly array_intersect_assoc: (((value: Scalar | Value) => FilterXdo<"array_intersect_assoc">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_intersect_assoc">));
+    readonly array_keys: () => FilterXdo<"array_keys">;
+    readonly array_lower: () => FilterXdo<"array_lower">;
+    readonly array_merge: (((value: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"array_merge">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_merge">));
+    readonly array_merge_recursive: (((value: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"array_merge_recursive">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_merge_recursive">));
+    readonly array_pop: () => FilterXdo<"array_pop">;
+    readonly array_push: (((value: Scalar | Value) => FilterXdo<"array_push">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_push">));
+    readonly array_push_conditional: (((value: Scalar | Value, conditional: Scalar | Value) => FilterXdo<"array_push_conditional">) & ((args: {
+        value: Scalar | Value;
+        conditional: Scalar | Value;
+    }) => FilterXdo<"array_push_conditional">));
+    readonly array_remove: (((value: Scalar | Value, path: Scalar | Value, strict?: Scalar | Value) => FilterXdo<"array_remove">) & ((args: {
+        value: Scalar | Value;
+        path: Scalar | Value;
+        strict?: Scalar | Value;
+    }) => FilterXdo<"array_remove">));
+    readonly array_replace: (((match: Scalar | Value, result: Scalar | Value) => FilterXdo<"array_replace">) & ((args: {
+        match: Scalar | Value;
+        result: Scalar | Value;
+    }) => FilterXdo<"array_replace">));
+    readonly array_set: (((path: Scalar | Value, value: Scalar | Value) => FilterXdo<"array_set">) & ((args: {
+        path: Scalar | Value;
+        value: Scalar | Value;
+    }) => FilterXdo<"array_set">));
+    readonly array_shift: () => FilterXdo<"array_shift">;
+    readonly array_shuffle: () => FilterXdo<"array_shuffle">;
+    readonly array_slice: (((offset: Scalar | Value, length?: Scalar | Value) => FilterXdo<"array_slice">) & ((args: {
+        offset: Scalar | Value;
+        length?: Scalar | Value;
+    }) => FilterXdo<"array_slice">));
+    readonly array_unshift: (((value: Scalar | Value) => FilterXdo<"array_unshift">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"array_unshift">));
+    readonly array_upmerge: (((match: Scalar | Value, node: Scalar | Value) => FilterXdo<"array_upmerge">) & ((args: {
+        match: Scalar | Value;
+        node: Scalar | Value;
+    }) => FilterXdo<"array_upmerge">));
+    readonly array_values: () => FilterXdo<"array_values">;
+    readonly asin: () => FilterXdo<"asin">;
+    readonly asinh: () => FilterXdo<"asinh">;
+    readonly atan: () => FilterXdo<"atan">;
+    readonly atanh: () => FilterXdo<"atanh">;
+    readonly avg: () => FilterXdo<"avg">;
+    readonly base64_decode: () => FilterXdo<"base64_decode">;
+    readonly base64_decode_urlsafe: () => FilterXdo<"base64_decode_urlsafe">;
+    readonly base64_encode: () => FilterXdo<"base64_encode">;
+    readonly base64_encode_urlsafe: () => FilterXdo<"base64_encode_urlsafe">;
+    readonly base_convert: (((from_base: Scalar | Value, to_base: Scalar | Value) => FilterXdo<"base_convert">) & ((args: {
+        from_base: Scalar | Value;
+        to_base: Scalar | Value;
+    }) => FilterXdo<"base_convert">));
+    readonly bin2hex: () => FilterXdo<"bin2hex">;
+    readonly bindec: () => FilterXdo<"bindec">;
+    readonly bitwise_and: (((value: Scalar | Value) => FilterXdo<"bitwise_and">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"bitwise_and">));
+    readonly bitwise_not: () => FilterXdo<"bitwise_not">;
+    readonly bitwise_or: (((value: Scalar | Value) => FilterXdo<"bitwise_or">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"bitwise_or">));
+    readonly bitwise_xor: (((value: Scalar | Value) => FilterXdo<"bitwise_xor">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"bitwise_xor">));
+    readonly capitalize: () => FilterXdo<"capitalize">;
+    readonly ceil: () => FilterXdo<"ceil">;
+    readonly clamp_max: (((max: Scalar | Value) => FilterXdo<"clamp_max">) & ((args: {
+        max: Scalar | Value;
+    }) => FilterXdo<"clamp_max">));
+    readonly clamp_min: (((min: Scalar | Value) => FilterXdo<"clamp_min">) & ((args: {
+        min: Scalar | Value;
+    }) => FilterXdo<"clamp_min">));
+    readonly concat: (((value: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"concat">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"concat">));
+    readonly contains: (((search: Scalar | Value) => FilterXdo<"contains">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"contains">));
+    readonly convert_encoding: (((to: Scalar | Value, from: Scalar | Value) => FilterXdo<"convert_encoding">) & ((args: {
+        to: Scalar | Value;
+        from: Scalar | Value;
+    }) => FilterXdo<"convert_encoding">));
+    readonly cos: () => FilterXdo<"cos">;
+    readonly count: () => FilterXdo<"count">;
+    readonly create_object: (((values: Scalar | Value) => FilterXdo<"create_object">) & ((args: {
+        values: Scalar | Value;
+    }) => FilterXdo<"create_object">));
+    readonly create_object_from_entries: () => FilterXdo<"create_object_from_entries">;
+    readonly crypto_jwe_decode: (((check_claims: Scalar | Value, key: Scalar | Value, key_algorithm: Scalar | Value, content_algorithm: Scalar | Value, timeDrift?: Scalar | Value) => FilterXdo<"crypto_jwe_decode">) & ((args: {
+        check_claims: Scalar | Value;
+        key: Scalar | Value;
+        key_algorithm: Scalar | Value;
+        content_algorithm: Scalar | Value;
+        timeDrift?: Scalar | Value;
+    }) => FilterXdo<"crypto_jwe_decode">));
+    readonly crypto_jwe_encode: (((headers: Scalar | Value, key: Scalar | Value, key_algorithm: Scalar | Value, content_algorithm: Scalar | Value, ttl?: Scalar | Value) => FilterXdo<"crypto_jwe_encode">) & ((args: {
+        headers: Scalar | Value;
+        key: Scalar | Value;
+        key_algorithm: Scalar | Value;
+        content_algorithm: Scalar | Value;
+        ttl?: Scalar | Value;
+    }) => FilterXdo<"crypto_jwe_encode">));
+    readonly crypto_jws_decode: (((check_claims: Scalar | Value, key: Scalar | Value, algorithm: Scalar | Value, timeDrift?: Scalar | Value) => FilterXdo<"crypto_jws_decode">) & ((args: {
+        check_claims: Scalar | Value;
+        key: Scalar | Value;
+        algorithm: Scalar | Value;
+        timeDrift?: Scalar | Value;
+    }) => FilterXdo<"crypto_jws_decode">));
+    readonly crypto_jws_encode: (((headers: Scalar | Value, key: Scalar | Value, algorithm: Scalar | Value, ttl?: Scalar | Value) => FilterXdo<"crypto_jws_encode">) & ((args: {
+        headers: Scalar | Value;
+        key: Scalar | Value;
+        algorithm: Scalar | Value;
+        ttl?: Scalar | Value;
+    }) => FilterXdo<"crypto_jws_encode">));
+    readonly csv_create: (((rows: Scalar | Value, separator: Scalar | Value, enclosure: Scalar | Value, escape: Scalar | Value) => FilterXdo<"csv_create">) & ((args: {
+        rows: Scalar | Value;
+        separator: Scalar | Value;
+        enclosure: Scalar | Value;
+        escape: Scalar | Value;
+    }) => FilterXdo<"csv_create">));
+    readonly csv_decode: (((separator: Scalar | Value, enclosure: Scalar | Value, escape: Scalar | Value) => FilterXdo<"csv_decode">) & ((args: {
+        separator: Scalar | Value;
+        enclosure: Scalar | Value;
+        escape: Scalar | Value;
+    }) => FilterXdo<"csv_decode">));
+    readonly csv_encode: (((separator: Scalar | Value, enclosure: Scalar | Value, escape: Scalar | Value) => FilterXdo<"csv_encode">) & ((args: {
+        separator: Scalar | Value;
+        enclosure: Scalar | Value;
+        escape: Scalar | Value;
+    }) => FilterXdo<"csv_encode">));
+    readonly csv_parse: (((separator: Scalar | Value, enclosure: Scalar | Value, escape: Scalar | Value) => FilterXdo<"csv_parse">) & ((args: {
+        separator: Scalar | Value;
+        enclosure: Scalar | Value;
+        escape: Scalar | Value;
+    }) => FilterXdo<"csv_parse">));
+    readonly decbin: () => FilterXdo<"decbin">;
+    readonly dechex: () => FilterXdo<"dechex">;
+    readonly decoct: () => FilterXdo<"decoct">;
+    readonly decrypt: (((algorithm: Scalar | Value, key: Scalar | Value, iv: Scalar | Value) => FilterXdo<"decrypt">) & ((args: {
+        algorithm: Scalar | Value;
+        key: Scalar | Value;
+        iv: Scalar | Value;
+    }) => FilterXdo<"decrypt">));
+    readonly deg2rad: () => FilterXdo<"deg2rad">;
+    readonly detect_encoding: (((encodings?: Scalar | Value) => FilterXdo<"detect_encoding">) & ((args: {
+        encodings?: Scalar | Value;
+    }) => FilterXdo<"detect_encoding">));
+    readonly div: (((value: Scalar | Value) => FilterXdo<"div">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"div">));
+    readonly empty: () => FilterXdo<"empty">;
+    readonly encrypt: (((algorithm: Scalar | Value, key: Scalar | Value, iv: Scalar | Value) => FilterXdo<"encrypt">) & ((args: {
+        algorithm: Scalar | Value;
+        key: Scalar | Value;
+        iv: Scalar | Value;
+    }) => FilterXdo<"encrypt">));
+    readonly ends_with: (((search: Scalar | Value) => FilterXdo<"ends_with">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"ends_with">));
+    readonly epochms_add_ms: (((milliseconds: Scalar | Value) => FilterXdo<"epochms_add_ms">) & ((args: {
+        milliseconds: Scalar | Value;
+    }) => FilterXdo<"epochms_add_ms">));
+    readonly epochms_add_secs: (((seconds: Scalar | Value) => FilterXdo<"epochms_add_secs">) & ((args: {
+        seconds: Scalar | Value;
+    }) => FilterXdo<"epochms_add_secs">));
+    readonly epochms_date: (((format: Scalar | Value, timezone?: Scalar | Value) => FilterXdo<"epochms_date">) & ((args: {
+        format: Scalar | Value;
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"epochms_date">));
+    readonly epochms_from_format: (((format: Scalar | Value, timezone?: Scalar | Value) => FilterXdo<"epochms_from_format">) & ((args: {
+        format: Scalar | Value;
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"epochms_from_format">));
+    readonly epochms_transform: (((format: Scalar | Value, timezone?: Scalar | Value) => FilterXdo<"epochms_transform">) & ((args: {
+        format: Scalar | Value;
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"epochms_transform">));
+    readonly eq: (((value: Scalar | Value) => FilterXdo<"eq">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"eq">));
+    readonly escape: () => FilterXdo<"escape">;
+    readonly even: () => FilterXdo<"even">;
+    readonly every: (((code: Scalar | Value | LambdaBody<"every">, timeout?: Scalar | Value) => FilterXdo<"every">) & ((args: {
+        code: Scalar | Value | LambdaBody<"every">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"every">));
+    readonly exp: () => FilterXdo<"exp">;
+    readonly filter: (((code: Scalar | Value | LambdaBody<"filter">, timeout?: Scalar | Value) => FilterXdo<"filter">) & ((args: {
+        code: Scalar | Value | LambdaBody<"filter">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"filter">));
+    readonly filter_empty: (((path?: Scalar | Value) => FilterXdo<"filter_empty">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_empty">));
+    readonly filter_empty_array: (((path?: Scalar | Value) => FilterXdo<"filter_empty_array">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_empty_array">));
+    readonly filter_empty_object: (((path?: Scalar | Value) => FilterXdo<"filter_empty_object">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_empty_object">));
+    readonly filter_empty_text: (((path?: Scalar | Value) => FilterXdo<"filter_empty_text">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_empty_text">));
+    readonly filter_false: (((path?: Scalar | Value) => FilterXdo<"filter_false">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_false">));
+    readonly filter_null: (((path?: Scalar | Value) => FilterXdo<"filter_null">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_null">));
+    readonly filter_zero: (((path?: Scalar | Value) => FilterXdo<"filter_zero">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"filter_zero">));
+    readonly find: (((code: Scalar | Value | LambdaBody<"find">, timeout?: Scalar | Value) => FilterXdo<"find">) & ((args: {
+        code: Scalar | Value | LambdaBody<"find">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"find">));
+    readonly findIndex: (((code: Scalar | Value | LambdaBody<"findIndex">, timeout?: Scalar | Value) => FilterXdo<"findIndex">) & ((args: {
+        code: Scalar | Value | LambdaBody<"findIndex">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"findIndex">));
+    readonly first: () => FilterXdo<"first">;
+    readonly first_notempty: (((value: Scalar | Value) => FilterXdo<"first_notempty">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"first_notempty">));
+    readonly first_notnull: (((value: Scalar | Value) => FilterXdo<"first_notnull">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"first_notnull">));
+    readonly flatten: () => FilterXdo<"flatten">;
+    readonly floor: () => FilterXdo<"floor">;
+    readonly from_utf8: () => FilterXdo<"from_utf8">;
+    readonly fsort: (((path?: Scalar | Value, type?: "text" | "itext" | "natural" | "inatural" | "number" | Value, asc?: Scalar | Value) => FilterXdo<"fsort">) & ((args: {
+        path?: Scalar | Value;
+        type?: "text" | "itext" | "natural" | "inatural" | "number" | Value;
+        asc?: Scalar | Value;
+    }) => FilterXdo<"fsort">));
+    readonly get: (((path: Scalar | Value, default_?: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"get">) & ((args: {
+        path: Scalar | Value;
+        default_?: Scalar | Value;
+    }) => FilterXdo<"get">));
+    readonly gt: (((value: Scalar | Value) => FilterXdo<"gt">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"gt">));
+    readonly gte: (((value: Scalar | Value) => FilterXdo<"gte">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"gte">));
+    readonly has: (((path: Scalar | Value) => FilterXdo<"has">) & ((args: {
+        path: Scalar | Value;
+    }) => FilterXdo<"has">));
+    readonly hex2bin: () => FilterXdo<"hex2bin">;
+    readonly hexdec: () => FilterXdo<"hexdec">;
+    readonly hmac_md5: (((key: Scalar | Value, raw?: Scalar | Value) => FilterXdo<"hmac_md5">) & ((args: {
+        key: Scalar | Value;
+        raw?: Scalar | Value;
+    }) => FilterXdo<"hmac_md5">));
+    readonly hmac_sha1: (((key: Scalar | Value, raw?: Scalar | Value) => FilterXdo<"hmac_sha1">) & ((args: {
+        key: Scalar | Value;
+        raw?: Scalar | Value;
+    }) => FilterXdo<"hmac_sha1">));
+    readonly hmac_sha256: (((key: Scalar | Value, raw?: Scalar | Value) => FilterXdo<"hmac_sha256">) & ((args: {
+        key: Scalar | Value;
+        raw?: Scalar | Value;
+    }) => FilterXdo<"hmac_sha256">));
+    readonly hmac_sha384: (((key: Scalar | Value, raw?: Scalar | Value) => FilterXdo<"hmac_sha384">) & ((args: {
+        key: Scalar | Value;
+        raw?: Scalar | Value;
+    }) => FilterXdo<"hmac_sha384">));
+    readonly hmac_sha512: (((key: Scalar | Value, raw?: Scalar | Value) => FilterXdo<"hmac_sha512">) & ((args: {
+        key: Scalar | Value;
+        raw?: Scalar | Value;
+    }) => FilterXdo<"hmac_sha512">));
+    readonly icontains: (((search: Scalar | Value) => FilterXdo<"icontains">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"icontains">));
+    readonly iends_with: (((search: Scalar | Value) => FilterXdo<"iends_with">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"iends_with">));
+    readonly in: (((search: Scalar | Value) => FilterXdo<"in">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"in">));
+    readonly index_by: (((path: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"index_by">) & ((args: {
+        path: Scalar | Value;
+    }) => FilterXdo<"index_by">));
+    readonly is_array: () => FilterXdo<"is_array">;
+    readonly is_bool: () => FilterXdo<"is_bool">;
+    readonly is_decimal: () => FilterXdo<"is_decimal">;
+    readonly is_int: () => FilterXdo<"is_int">;
+    readonly is_object: () => FilterXdo<"is_object">;
+    readonly is_text: () => FilterXdo<"is_text">;
+    readonly is_uuid: () => FilterXdo<"is_uuid">;
+    readonly istarts_with: (((search: Scalar | Value) => FilterXdo<"istarts_with">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"istarts_with">));
+    readonly join: (((separator: Scalar | Value) => FilterXdo<"join">) & ((args: {
+        separator: Scalar | Value;
+    }) => FilterXdo<"join">));
+    readonly json_decode: () => FilterXdo<"json_decode">;
+    readonly json_encode: () => FilterXdo<"json_encode">;
+    readonly jwe_decode: (((arg1: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"jwe_decode">) & ((args: {
+        arg1: Scalar | Value;
+    }) => FilterXdo<"jwe_decode">));
+    readonly jwe_encode: (((arg1: Scalar | Value, ...rest: (Scalar | Value)[]) => FilterXdo<"jwe_encode">) & ((args: {
+        arg1: Scalar | Value;
+    }) => FilterXdo<"jwe_encode">));
+    readonly lambda: (((code: Scalar | Value | LambdaBody<"fl.lambda">, timeout?: Scalar | Value) => FilterXdo<"lambda">) & ((args: {
+        code: Scalar | Value | LambdaBody<"fl.lambda">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"lambda">));
+    readonly last: () => FilterXdo<"last">;
+    readonly list_encodings: () => FilterXdo<"list_encodings">;
+    readonly ln: () => FilterXdo<"ln">;
+    readonly log: (((base: Scalar | Value) => FilterXdo<"log">) & ((args: {
+        base: Scalar | Value;
+    }) => FilterXdo<"log">));
+    readonly log10: () => FilterXdo<"log10">;
+    readonly lower: () => FilterXdo<"lower">;
+    readonly lt: (((value: Scalar | Value) => FilterXdo<"lt">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"lt">));
+    readonly lte: (((value: Scalar | Value) => FilterXdo<"lte">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"lte">));
+    readonly ltrim: (((mask?: Scalar | Value) => FilterXdo<"ltrim">) & ((args: {
+        mask?: Scalar | Value;
+    }) => FilterXdo<"ltrim">));
+    readonly map: (((code: Scalar | Value | LambdaBody<"map">, timeout?: Scalar | Value) => FilterXdo<"map">) & ((args: {
+        code: Scalar | Value | LambdaBody<"map">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"map">));
+    readonly max: (((bound?: Scalar | Value) => FilterXdo<"max">) & ((args: {
+        bound?: Scalar | Value;
+    }) => FilterXdo<"max">));
+    readonly md5: (((raw?: Scalar | Value) => FilterXdo<"md5">) & ((args: {
+        raw?: Scalar | Value;
+    }) => FilterXdo<"md5">));
+    readonly min: (((bound?: Scalar | Value) => FilterXdo<"min">) & ((args: {
+        bound?: Scalar | Value;
+    }) => FilterXdo<"min">));
+    readonly mod: (((value: Scalar | Value) => FilterXdo<"mod">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"mod">));
+    readonly ms_to_secs: () => FilterXdo<"ms_to_secs">;
+    readonly mul: (((value: Scalar | Value) => FilterXdo<"mul">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"mul">));
+    readonly ne: (((value: Scalar | Value) => FilterXdo<"ne">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"ne">));
+    readonly not: () => FilterXdo<"not">;
+    readonly null: () => FilterXdo<"null">;
+    readonly num_max: (((value: Scalar | Value) => FilterXdo<"num_max">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"num_max">));
+    readonly num_min: (((value: Scalar | Value) => FilterXdo<"num_min">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"num_min">));
+    readonly number_format: (((decimals: Scalar | Value, decimal_separator: Scalar | Value, thousands_separator: Scalar | Value) => FilterXdo<"number_format">) & ((args: {
+        decimals: Scalar | Value;
+        decimal_separator: Scalar | Value;
+        thousands_separator: Scalar | Value;
+    }) => FilterXdo<"number_format">));
+    readonly octdec: () => FilterXdo<"octdec">;
+    readonly odd: () => FilterXdo<"odd">;
+    readonly pick: (((keys: Scalar | Value) => FilterXdo<"pick">) & ((args: {
+        keys: Scalar | Value;
+    }) => FilterXdo<"pick">));
+    readonly pow: (((exp: Scalar | Value) => FilterXdo<"pow">) & ((args: {
+        exp: Scalar | Value;
+    }) => FilterXdo<"pow">));
+    readonly prepend: (((value: Scalar | Value, path: Scalar | Value) => FilterXdo<"prepend">) & ((args: {
+        value: Scalar | Value;
+        path: Scalar | Value;
+    }) => FilterXdo<"prepend">));
+    readonly product: () => FilterXdo<"product">;
+    readonly querystring_parse: () => FilterXdo<"querystring_parse">;
+    readonly rad2deg: () => FilterXdo<"rad2deg">;
+    readonly range: (((start: Scalar | Value, stop: Scalar | Value) => FilterXdo<"range">) & ((args: {
+        start: Scalar | Value;
+        stop: Scalar | Value;
+    }) => FilterXdo<"range">));
+    readonly reduce: (((initial_value: Scalar | Value, code: Scalar | Value | LambdaBody<"reduce">, timeout?: Scalar | Value) => FilterXdo<"reduce">) & ((args: {
+        initial_value: Scalar | Value;
+        code: Scalar | Value | LambdaBody<"reduce">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"reduce">));
+    readonly regex_match: (((subject: Scalar | Value) => FilterXdo<"regex_match">) & ((args: {
+        subject: Scalar | Value;
+    }) => FilterXdo<"regex_match">));
+    readonly regex_match_all: (((subject: Scalar | Value) => FilterXdo<"regex_match_all">) & ((args: {
+        subject: Scalar | Value;
+    }) => FilterXdo<"regex_match_all">));
+    readonly regex_quote: (((delimiter?: Scalar | Value) => FilterXdo<"regex_quote">) & ((args: {
+        delimiter?: Scalar | Value;
+    }) => FilterXdo<"regex_quote">));
+    readonly regex_replace: (((replacement: Scalar | Value, subject: Scalar | Value) => FilterXdo<"regex_replace">) & ((args: {
+        replacement: Scalar | Value;
+        subject: Scalar | Value;
+    }) => FilterXdo<"regex_replace">));
+    readonly regex_test: (((subject: Scalar | Value) => FilterXdo<"regex_test">) & ((args: {
+        subject: Scalar | Value;
+    }) => FilterXdo<"regex_test">));
+    readonly reverse: () => FilterXdo<"reverse">;
+    readonly round: (((precision?: Scalar | Value) => FilterXdo<"round">) & ((args: {
+        precision?: Scalar | Value;
+    }) => FilterXdo<"round">));
+    readonly rsort: () => FilterXdo<"rsort">;
+    readonly rtrim: (((mask?: Scalar | Value) => FilterXdo<"rtrim">) & ((args: {
+        mask?: Scalar | Value;
+    }) => FilterXdo<"rtrim">));
+    readonly safe_array: () => FilterXdo<"safe_array">;
+    readonly secs_to_ms: () => FilterXdo<"secs_to_ms">;
+    readonly secureid_decode: (((salt: Scalar | Value) => FilterXdo<"secureid_decode">) & ((args: {
+        salt: Scalar | Value;
+    }) => FilterXdo<"secureid_decode">));
+    readonly secureid_encode: (((salt: Scalar | Value) => FilterXdo<"secureid_encode">) & ((args: {
+        salt: Scalar | Value;
+    }) => FilterXdo<"secureid_encode">));
+    readonly set: (((path: Scalar | Value, value: Scalar | Value) => FilterXdo<"set">) & ((args: {
+        path: Scalar | Value;
+        value: Scalar | Value;
+    }) => FilterXdo<"set">));
+    readonly set_conditional: (((path: Scalar | Value, value: Scalar | Value, conditional: Scalar | Value) => FilterXdo<"set_conditional">) & ((args: {
+        path: Scalar | Value;
+        value: Scalar | Value;
+        conditional: Scalar | Value;
+    }) => FilterXdo<"set_conditional">));
+    readonly set_ifnotempty: (((path: Scalar | Value, value: Scalar | Value) => FilterXdo<"set_ifnotempty">) & ((args: {
+        path: Scalar | Value;
+        value: Scalar | Value;
+    }) => FilterXdo<"set_ifnotempty">));
+    readonly set_ifnotnull: (((path: Scalar | Value, value: Scalar | Value) => FilterXdo<"set_ifnotnull">) & ((args: {
+        path: Scalar | Value;
+        value: Scalar | Value;
+    }) => FilterXdo<"set_ifnotnull">));
+    readonly sha1: (((raw?: Scalar | Value) => FilterXdo<"sha1">) & ((args: {
+        raw?: Scalar | Value;
+    }) => FilterXdo<"sha1">));
+    readonly sha256: (((raw?: Scalar | Value) => FilterXdo<"sha256">) & ((args: {
+        raw?: Scalar | Value;
+    }) => FilterXdo<"sha256">));
+    readonly sha384: (((raw?: Scalar | Value) => FilterXdo<"sha384">) & ((args: {
+        raw?: Scalar | Value;
+    }) => FilterXdo<"sha384">));
+    readonly sha512: (((raw?: Scalar | Value) => FilterXdo<"sha512">) & ((args: {
+        raw?: Scalar | Value;
+    }) => FilterXdo<"sha512">));
+    readonly sin: () => FilterXdo<"sin">;
+    readonly some: (((code: Scalar | Value | LambdaBody<"some">, timeout?: Scalar | Value) => FilterXdo<"some">) & ((args: {
+        code: Scalar | Value | LambdaBody<"some">;
+        timeout?: Scalar | Value;
+    }) => FilterXdo<"some">));
+    readonly sort: () => FilterXdo<"sort">;
+    readonly splice: (((offset: Scalar | Value, length?: Scalar | Value, path?: Scalar | Value) => FilterXdo<"splice">) & ((args: {
+        offset: Scalar | Value;
+        length?: Scalar | Value;
+        path?: Scalar | Value;
+    }) => FilterXdo<"splice">));
+    readonly split: (((separator: Scalar | Value) => FilterXdo<"split">) & ((args: {
+        separator: Scalar | Value;
+    }) => FilterXdo<"split">));
+    readonly sprintf: (...args: (Scalar | Value)[]) => FilterXdo<"sprintf">;
+    readonly sql_alias: () => FilterXdo<"sql_alias">;
+    readonly sql_esc: () => FilterXdo<"sql_esc">;
+    readonly sqrt: () => FilterXdo<"sqrt">;
+    readonly starts_with: (((search: Scalar | Value) => FilterXdo<"starts_with">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"starts_with">));
+    readonly string_replace: (((search: Scalar | Value, replacement: Scalar | Value) => FilterXdo<"string_replace">) & ((args: {
+        search: Scalar | Value;
+        replacement: Scalar | Value;
+    }) => FilterXdo<"string_replace">));
+    readonly strip_accents: () => FilterXdo<"strip_accents">;
+    readonly strip_tags: (((exclude?: Scalar | Value) => FilterXdo<"strip_tags">) & ((args: {
+        exclude?: Scalar | Value;
+    }) => FilterXdo<"strip_tags">));
+    readonly stripos: (((search: Scalar | Value) => FilterXdo<"stripos">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"stripos">));
+    readonly strlen: () => FilterXdo<"strlen">;
+    readonly strpos: (((search: Scalar | Value) => FilterXdo<"strpos">) & ((args: {
+        search: Scalar | Value;
+    }) => FilterXdo<"strpos">));
+    readonly sub: (((value: Scalar | Value) => FilterXdo<"sub">) & ((args: {
+        value: Scalar | Value;
+    }) => FilterXdo<"sub">));
+    readonly substr: (((start: Scalar | Value, length: Scalar | Value) => FilterXdo<"substr">) & ((args: {
+        start: Scalar | Value;
+        length: Scalar | Value;
+    }) => FilterXdo<"substr">));
+    readonly sum: () => FilterXdo<"sum">;
+    readonly tan: () => FilterXdo<"tan">;
+    readonly text_escape: () => FilterXdo<"text_escape">;
+    readonly text_unescape: () => FilterXdo<"text_unescape">;
+    readonly to_bool: () => FilterXdo<"to_bool">;
+    readonly to_decimal: () => FilterXdo<"to_decimal">;
+    readonly to_epoch_day: (((timezone?: Scalar | Value) => FilterXdo<"to_epoch_day">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epoch_day">));
+    readonly to_epoch_hour: (((timezone?: Scalar | Value) => FilterXdo<"to_epoch_hour">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epoch_hour">));
+    readonly to_epoch_minute: (((timezone?: Scalar | Value) => FilterXdo<"to_epoch_minute">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epoch_minute">));
+    readonly to_epoch_ms: (((timezone?: Scalar | Value) => FilterXdo<"to_epoch_ms">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epoch_ms">));
+    readonly to_epoch_sec: (((timezone?: Scalar | Value) => FilterXdo<"to_epoch_sec">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epoch_sec">));
+    readonly to_epochms: (((timezone?: Scalar | Value) => FilterXdo<"to_epochms">) & ((args: {
+        timezone?: Scalar | Value;
+    }) => FilterXdo<"to_epochms">));
+    readonly to_expr: () => FilterXdo<"to_expr">;
+    readonly to_geo_linestring: () => FilterXdo<"to_geo_linestring">;
+    readonly to_geo_multilinestring: () => FilterXdo<"to_geo_multilinestring">;
+    readonly to_geo_multipoint: () => FilterXdo<"to_geo_multipoint">;
+    readonly to_geo_multipolygon: () => FilterXdo<"to_geo_multipolygon">;
+    readonly to_geo_point: () => FilterXdo<"to_geo_point">;
+    readonly to_geo_polygon: () => FilterXdo<"to_geo_polygon">;
+    readonly to_int: () => FilterXdo<"to_int">;
+    readonly to_text: () => FilterXdo<"to_text">;
+    readonly to_utf8: () => FilterXdo<"to_utf8">;
+    readonly transform: (((expression: Scalar | Value) => FilterXdo<"transform">) & ((args: {
+        expression: Scalar | Value;
+    }) => FilterXdo<"transform">));
+    readonly trim: (((mask?: Scalar | Value) => FilterXdo<"trim">) & ((args: {
+        mask?: Scalar | Value;
+    }) => FilterXdo<"trim">));
+    readonly uid: () => FilterXdo<"uid">;
+    readonly unique: (((path?: Scalar | Value) => FilterXdo<"unique">) & ((args: {
+        path?: Scalar | Value;
+    }) => FilterXdo<"unique">));
+    readonly unpick: (((keys: Scalar | Value) => FilterXdo<"unpick">) & ((args: {
+        keys: Scalar | Value;
+    }) => FilterXdo<"unpick">));
+    readonly unset: (((path: Scalar | Value) => FilterXdo<"unset">) & ((args: {
+        path: Scalar | Value;
+    }) => FilterXdo<"unset">));
+    readonly upper: () => FilterXdo<"upper">;
+    readonly url_addarg: (((key: Scalar | Value, value: Scalar | Value, encoding_rfc3986?: Scalar | Value) => FilterXdo<"url_addarg">) & ((args: {
+        key: Scalar | Value;
+        value: Scalar | Value;
+        encoding_rfc3986?: Scalar | Value;
+    }) => FilterXdo<"url_addarg">));
+    readonly url_decode: () => FilterXdo<"url_decode">;
+    readonly url_decode_rfc3986: () => FilterXdo<"url_decode_rfc3986">;
+    readonly url_delarg: (((key: Scalar | Value) => FilterXdo<"url_delarg">) & ((args: {
+        key: Scalar | Value;
+    }) => FilterXdo<"url_delarg">));
+    readonly url_encode: () => FilterXdo<"url_encode">;
+    readonly url_encode_rfc3986: () => FilterXdo<"url_encode_rfc3986">;
+    readonly url_getarg: (((key: Scalar | Value, default_?: Scalar | Value) => FilterXdo<"url_getarg">) & ((args: {
+        key: Scalar | Value;
+        default_?: Scalar | Value;
+    }) => FilterXdo<"url_getarg">));
+    readonly url_hasarg: (((key: Scalar | Value) => FilterXdo<"url_hasarg">) & ((args: {
+        key: Scalar | Value;
+    }) => FilterXdo<"url_hasarg">));
+    readonly url_parse: () => FilterXdo<"url_parse">;
+    readonly uuid4: () => FilterXdo<"uuid4">;
+    readonly xml_decode: () => FilterXdo<"xml_decode">;
+    readonly yaml_decode: () => FilterXdo<"yaml_decode">;
+    readonly yaml_encode: (((options?: Scalar | Value, inline?: Scalar | Value, indent?: Scalar | Value) => FilterXdo<"yaml_encode">) & ((args: {
+        options?: Scalar | Value;
+        inline?: Scalar | Value;
+        indent?: Scalar | Value;
+    }) => FilterXdo<"yaml_encode">));
+};
+
+/**
+ * Schema-DSL interpreter. Turns a declarative statement schema's
+ * `transform` rules into a runtime encoder, so the ~169 declarative statements
+ * are driven by data (a `StatementSpec`) rather than hand-written per statement.
+ *
+ * A `StatementSpec` is a flat list of `FieldRule`s — one per authored field the
+ * statement consumes — mirroring the engine's `transform.args` / `transform.blocks`
+ * entries. Each rule says where one authored field lands in the stored statement:
+ *  - `route: { kind: "as" }`             → the statement's top-level `as`.
+ *  - `route: { kind: "context-plain" }`  → a plain string written at `context.<path>`.
+ *  - `route: { kind: "context-spread" }` → a Value's `{value,tag,filters}` spread
+ *      directly into `context` (the `!assign context` rule).
+ *  - `route: { kind: "context-nest" }`   → a Value's `{value,tag,filters}` nested
+ *      under `context.<path>` (the `!assign context.<key>` rule).
+ *
+ * Rules carry optionality + an optional string `default` (the schema's `?=X`).
+ * `output` (whether the stored item carries `output:{filters:[]}`) is NOT
+ * derivable from the transform schema — it is engine statement-class metadata
+ * (e.g. `uuid4` has an `as` but no `output`; `return` has a value block but no
+ * `output`). The codegen pins it from the persisted golden fixture,
+ * never guessing.
+ *
+ * Validated against real persisted fixtures (math_add, bitwise_and, object_keys,
+ * array_push, array_pop). The codegen pipeline populates the
+ * spec catalog from the Xano engine's schema definitions; uninterpretable schemas are
+ * logged, never guessed.
+ */
+
+/**
+ * What kind of authored value a field consumes:
+ *  - `string`     — a plain `static:text` arg.
+ *  - `boolean`    — a plain `static:bool` arg, authored as a real boolean.
+ *  - `value`      — a `!kinds assign` tagged Value.
+ *  - `comparison` — a `Condition` expression tree (the `!compare` directive).
+ */
+type FieldType = "string" | "boolean" | "value" | "comparison";
+/** Where one authored field lands in the stored statement. */
+type Route = {
+    kind: "as";
+} | {
+    kind: "context-plain";
+    path: string;
+} | {
+    kind: "context-spread";
+} | {
+    kind: "context-nest";
+    path: string;
+} | {
+    kind: "context-compare";
+    path: string;
+} | {
+    kind: "input";
+    name: string;
+};
+/**
+ * Per-statement envelope shape, pinned from the persisted fixture — the
+ * engine-class metadata that isn't in the transform schema. "Full" statements
+ * (api_request, db ops, file ops) carry richer `input[]` entries and extra
+ * top-level keys; lean statements (math, array, object) carry none of these.
+ */
+interface EnvelopeProfile {
+    /** `input[]` entries carry `ignore/expand/children` (vs the lean `{name,value,tag,filters}`). */
+    inputFull?: boolean;
+    /** Always emit `as` (default `""`) even when no rule sets it. */
+    emitAs?: boolean;
+    /** Emit `description:""`. */
+    description?: boolean;
+    /** Emit `settings_registry:[]`. */
+    settingsRegistry?: boolean;
+    /** Emit `addon:[]`. */
+    addon?: boolean;
+    /** `output` is the rich `{customize:false,filters:[],items:[]}` (vs lean `{filters:[]}`). */
+    richOutput?: boolean;
+}
+/** One authored field → its routing into the stored statement. */
+interface FieldRule {
+    /** Authored field name (e.g. "as", "name", "value", "filename"). */
+    field: string;
+    /** String arg vs Value(assign) — determines how `default`/missing is handled. */
+    type: FieldType;
+    /** Optional in authoring (the schema's trailing `?`). */
+    optional: boolean;
+    /** Literal default for string fields when not provided (the schema's `?=X`). */
+    default?: string;
+    /**
+     * The field's closed set of legal values, harvested from the engine's runtime
+     * input schema ({@link ./input-schema.ts}) and attached by
+     * {@link ./enums.ts attachEnums}. Absent on all but the ~36 constrained
+     * fields. Drives three things: the generated factory's literal-union
+     * signature, the bare-literal shorthand, and the encode-time guard in
+     * {@link encodeFromSpec}.
+     */
+    enum?: string[];
+    /**
+     * Written as an empty text constant when the author omits it, rather than
+     * left out. Set by `overrides.ts` for a field that is optional to author but
+     * that the engine reads unconditionally — it refuses a statement missing the
+     * key at run time, after a clean deploy. The empty constant is what the
+     * engine's own XanoScript form stores for "unset". An authored `null` writes
+     * no key at all — the spelling a pull uses for a statement stored without it.
+     */
+    emptyWhenAbsent?: true;
+    /** Routing target. */
+    route: Route;
+}
+interface StatementSpec {
+    /** Stored statement name, e.g. "mvp:math_add". */
+    name: string;
+    /**
+     * The `s.` path the author calls this statement by (`"s.math.add"`) — what
+     * every error names, since the stored name appears nowhere in authored code.
+     * Written by the codegen beside the name, so naming the factory costs no
+     * lookup table in the client bundle.
+     */
+    factory?: string;
+    /** Marks the engine's argNameIsVar family (informational; does not affect encoding). */
+    argNameIsVar?: boolean;
+    /** Ordered field rules. */
+    rules: FieldRule[];
+    /** Emit `output` when true (pinned from the golden fixture; shape per `envelope.richOutput`). */
+    output?: boolean;
+    /** Per-statement envelope shape pinned from the fixture; absent = lean. */
+    envelope?: EnvelopeProfile;
+}
+/**
+ * Authored `output` envelope shaping (the frontend's "Output" tab). Any of the
+ * three stored members may be set; omitted members keep their empty default.
+ * `filters` attaches a filter chain to the result variable; `customize`/`items`
+ * drive response field-mapping. Merged over the spec's default `output` shape.
+ *
+ * Prefer `asFilters` for the filter chain — it is typed, reaches every statement
+ * rather than the subset declaring an `output`, and guards the no-binding case.
+ * `filters` here remains the escape hatch for a chain the typed surface cannot
+ * express; setting both throws.
+ */
+interface OutputAuthored {
+    filters?: unknown[];
+    customize?: boolean;
+    items?: unknown[];
+}
+/**
+ * Authored inputs for a spec-driven statement, keyed by field name. Besides the
+ * spec's rule fields, five reserved envelope keys are honored: `disabled`,
+ * `description`, `mock`, and `asFilters` ({@link StatementAnnotations} —
+ * accepted on every statement) and `output` (an {@link OutputAuthored} shaping
+ * the result envelope, only where the statement carries one). No engine
+ * statement routes a rule field by any of those five names, so they are
+ * unambiguous.
+ */
+type Authored = Record<string, string | boolean | Value | Condition | OutputAuthored | FilterXdo[] | MockMap | undefined>;
+/** Encode authored inputs into a `Statement` using a spec's field rules. */
+declare function encodeFromSpec(spec: StatementSpec, authored: Authored): Statement;
+/** Register a spec on the statement registry; returns its factory. */
+declare function registerSpec(spec: StatementSpec): (authored: Authored) => Statement;
+
+declare const mathAdd: (varName: string, value: Value) => Statement;
+declare const mathSub: (varName: string, value: Value) => Statement;
+declare const mathMul: (varName: string, value: Value) => Statement;
+declare const mathDiv: (varName: string, value: Value) => Statement;
+declare const bitwiseAnd: (varName: string, value: Value) => Statement;
+declare const bitwiseOr: (varName: string, value: Value) => Statement;
+declare const bitwiseXor: (varName: string, value: Value) => Statement;
+declare const textAppend: (varName: string, value: Value) => Statement;
+declare const textPrepend: (varName: string, value: Value) => Statement;
+declare const objectKeys: (as: string, value: Value) => Statement;
+declare const objectValues: (as: string, value: Value) => Statement;
+declare const objectEntries: (as: string, value: Value) => Statement;
+/** Names of all statements produced by the generated catalog. */
+declare const GENERATED_STATEMENT_NAMES: string[];
+
+/**
+ * Typed, namespaced factories for the declarative statement catalog: every
+ * generated statement is reachable + autocomplete-discoverable as
+ * `generated.<namespace>.<method>({…})` (e.g. `generated.math.add`,
+ * `generated.db.get`). The unified public surface is `s` in ../s.ts, which
+ * merges these with the hand-authored control-flow specials.
+ */
+
+declare const generated: {
+    ai: {
+        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;
+                };
+            };
+        };
+    };
+    api: {
+        request: (a: {
+            as?: string;
+            url: Value;
+            method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH" | Value;
+            params?: Value;
+            headers?: Value;
+            timeout?: Value;
+            follow_location?: Value;
+            verify_host?: Value;
+            verify_peer?: Value;
+            ca_certificate?: Value;
+            certificate?: Value;
+            certificate_pass?: Value;
+            private_key?: Value;
+            private_key_pass?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        stream: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    array: {
+        difference: (a?: {
+            as?: string;
+            expr?: Value;
+            value?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        every: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        filter: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        filter_count: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        find: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        find_index: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        group_by: (a?: {
+            as?: string;
+            expr?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        has: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        intersection: (a?: {
+            as?: string;
+            expr?: Value;
+            value?: Value;
+            by?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        merge: (a?: {
+            name?: string;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        partition: (a?: {
+            expr?: Value;
+            as?: string;
+            if?: Condition;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        pop: (a?: {
+            name?: string;
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        push: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        shift: (a?: {
+            name?: string;
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        unshift: (a: {
+            name?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    await: (a?: {
+        as?: string;
+        ids?: Value;
+        timeout?: Value;
+        disabled?: boolean;
+        description?: string;
+        asFilters?: FilterXdo[];
+    }) => Statement;
+    cloud: {
+        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;
+        };
+        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;
+            };
+        };
+        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;
+            };
+        };
+        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;
+        };
+        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;
+            };
+        };
+    };
+    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;
+    };
+    db: {
+        set_datasource: (a: {
+            value: Value;
+            workspace_id?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    debug: {
+        log: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        stop: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    expect: {
+        to_be_defined: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_empty: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_false: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_greater_than: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_in_the_future: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_in_the_past: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_less_than: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_null: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_true: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_be_within: (a?: {
+            expr?: Value;
+            min?: Value;
+            max?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_contain: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_end_with: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_equal: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_match: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_not_be_defined: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_not_be_null: (a?: {
+            expr?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_not_equal: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        to_start_with: (a?: {
+            expr?: Value;
+            value?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    lambda: (a: {
+        as?: string;
+        code: Value | LambdaBody<"s.lambda">;
+        timeout?: Value;
+        disabled?: boolean;
+        description?: string;
+        asFilters?: FilterXdo[];
+    }) => Statement;
+    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;
+    };
+    mcp: {
+        oauth: {
+            complete: (a: {
+                as?: string;
+                request: Value;
+                decision: "approve" | "deny" | Value;
+                unsafe_user_id?: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+            request: (a: {
+                as?: string;
+                request: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+            revoke: (a: {
+                as?: string;
+                mcp_server: Value;
+                user_id?: Value;
+                grant_id?: Value;
+                all?: Value;
+                disabled?: boolean;
+                description?: string;
+                asFilters?: FilterXdo[];
+            }) => Statement;
+        };
+        progress: (a: {
+            progress: Value;
+            total?: Value;
+            message?: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+    };
+    microservice: {
+        request: (a: {
+            as?: string;
+            host: Value;
+            path: Value;
+            method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH" | Value;
+            params?: Value;
+            headers: Value;
+            timeout?: Value;
+            follow_location?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    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;
+    };
+    precondition: (a?: {
+        expr?: Condition;
+        error_type?: string;
+        error?: Value;
+        payload?: Value;
+        disabled?: boolean;
+        description?: string;
+    }) => Statement;
+    realtime: {
+        get_session: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    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;
+    };
+    security: {
+        check_password: (a: {
+            as?: string;
+            text_password: Value;
+            hash_password: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        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;
+        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;
+        create_rsa_key: (a?: {
+            as?: string;
+            bits?: Value;
+            format?: "object" | "base64" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        create_secret_key: (a?: {
+            as?: string;
+            bits?: Value;
+            format?: "object" | "base64" | Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        create_uuid: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        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;
+        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;
+        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;
+        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;
+        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;
+        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;
+        random_bytes: (a?: {
+            as?: string;
+            length?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        random_number: (a?: {
+            as?: string;
+            min?: Value;
+            max?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    storage: {
+        create_attachment: (a: {
+            as?: string;
+            value: Value;
+            access?: string;
+            filename?: Value;
+            include_meta?: boolean;
+            type?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        create_audio: (a: {
+            as?: string;
+            value: Value;
+            access?: string;
+            filename?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        create_file_resource: (a: {
+            as?: string;
+            filename: Value;
+            filedata: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        create_image: (a: {
+            as?: string;
+            value: Value;
+            access?: string;
+            filename?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        create_video: (a: {
+            as?: string;
+            value: Value;
+            access?: string;
+            filename?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        delete_file: (a: {
+            pathname: Value;
+            disabled?: boolean;
+            description?: string;
+            output?: OutputAuthored;
+        }) => Statement;
+        read_file_resource: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        sign_private_url: (a: {
+            as?: string;
+            pathname: Value;
+            ttl?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    stream: {
+        from_csv: (a: {
+            as?: string;
+            value: Value;
+            separator?: Value;
+            enclosure?: Value;
+            escape_char?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+            output?: OutputAuthored;
+        }) => Statement;
+        from_jsonl: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        from_request: (a: {
+            as?: string;
+            url: Value;
+            method?: Value;
+            params?: Value;
+            headers?: Value;
+            timeout?: Value;
+            follow_location?: Value;
+            verify_host?: Value;
+            verify_peer?: Value;
+            ca_certificate?: Value;
+            certificate?: Value;
+            certificate_pass?: Value;
+            private_key?: Value;
+            private_key_pass?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    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;
+    };
+    throw: (a: {
+        name?: string;
+        value: Value;
+        disabled?: boolean;
+        description?: string;
+    }) => Statement;
+    util: {
+        geo_distance: (a: {
+            as?: string;
+            latitude_1: Value;
+            longitude_1: Value;
+            latitude_2: Value;
+            longitude_2: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        get_all_input: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        get_env: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        get_vars: (a?: {
+            as?: string;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        ip_lookup: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        send_email: (a?: {
+            as?: string;
+            api_key?: Value;
+            service_provider?: "resend" | "xano" | 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;
+        set_header: (a: {
+            value: Value;
+            duplicates?: string;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        sleep: (a: {
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        template_engine: (a: {
+            as?: string;
+            value: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    webflow: {
+        request: (a: {
+            as?: string;
+            path: Value;
+            method?: Value;
+            params?: Value;
+            headers?: Value;
+            timeout?: Value;
+            follow_location?: Value;
+            verify_host?: Value;
+            verify_peer?: Value;
+            ca_certificate?: Value;
+            certificate?: Value;
+            certificate_pass?: Value;
+            private_key?: Value;
+            private_key_pass?: Value;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+    zip: {
+        add_to_archive: (a: {
+            file: Value;
+            filename: Value;
+            zip: Value;
+            password?: Value | null;
+            password_encryption?: Value | null;
+            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 | null;
+            disabled?: boolean;
+            description?: string;
+        }) => Statement;
+        extract: (a: {
+            as?: string;
+            zip: Value;
+            password?: Value | null;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+        view_contents: (a: {
+            as?: string;
+            zip: Value;
+            password?: Value | null;
+            disabled?: boolean;
+            description?: string;
+            asFilters?: FilterXdo[];
+        }) => Statement;
+    };
+};
+
+/** The kinds an argument can name. The local project entry is absence, not a spelling. */
+type SourceKind = "workspace" | "ephemeral" | "local-engine" | "release" | "tenant" | "file";
+
+/**
+ * The CLI's command registry — the single source of truth for what `xanosdk`
+ * accepts.
+ *
+ * Three consumers read this table and nothing else:
+ *   • `help.ts`  renders global and command-scoped help from it,
+ *   • `cli.ts`   validates the command/subcommand a user typed against it,
+ *   • the unknown-* errors list valid verbs from it (never a hand-written string).
+ *
+ * The dispatch chain in `cli.ts` still owns the lazy `await import(...)` per
+ * command — deliberately, so the browser-safe authoring bundle never pulls in
+ * the Node-only OAuth/deploy stack. A drift test pins the registry's keys to the
+ * commands that chain actually compares against, so the two cannot diverge
+ * silently even though they are written twice.
+ *
+ * Keep this module free of `node:*` imports for the same bundling reason.
+ */
+
+/** What a backend selector slot is FOR: read from, write to, run on, or act on. */
+type SelectorRole = "from" | "to" | "on" | "subject";
+/**
+ * What a slot means when nothing is typed into it.
+ *
+ * - `tracked` — the backend this project last deployed to.
+ * - `entry` — `deploy`'s source only: the project's own entry file, compiled.
+ * - `none` — the slot supplies nothing when absent: `generate` and `init --from`
+ *   need a source named, and `deploy --to` absent means the deploy's own
+ *   ephemeral or local-engine path rather than any backend here.
+ */
+type SelectorDefault = "tracked" | "entry" | "none";
+/**
+ * One backend selector slot, declared once on the flag or positional that takes
+ * it. Help renders the spellings from `accepted`, completion offers its bare
+ * kinds, the manifest publishes it, the parse-arm error for a missing value
+ * lists it, and `backend-slot.ts` parses with it — so a command cannot accept a
+ * kind its help does not show.
+ *
+ * `refused` names kinds that belong to the grammar but that THIS command cannot
+ * serve, each with the reason. They stay out of `accepted` (help does not offer
+ * them) and are refused with the reason rather than as unknown — an unknown
+ * kind reads as a typo, and the reason is what tells the reader whether to name
+ * another backend or reach for another command.
+ */
+interface SelectorSpec {
+    readonly accepted: readonly SourceKind[];
+    readonly role: SelectorRole;
+    readonly default: SelectorDefault;
+    readonly refused?: Readonly<Partial<Record<SourceKind, string>>>;
+}
+
+/**
+ * Agent-grounding manifest (DX follow-up). A machine-readable description of the
+ * entire xanosdk authoring surface — object kinds, statement catalog (with field
+ * schemas for the declarative statements), value constructors, and tag catalog —
+ * plus a human/LLM-readable `llms.txt` renderer.
+ *
+ * Everything here is DERIVED from the SDK's own sources of truth (the surface
+ * catalog, the generated statement specs, the kind registry, the value/tag
+ * primitives), so the manifest can never drift from what the SDK can actually
+ * emit. Regenerate the committed `manifest.json` / `llms.txt` with
+ * `npm run manifest`; the manifest test fails if they fall out of sync.
+ */
+
+/** A statement field, flattened from its generated spec rule. */
+interface ManifestField {
+    name: string;
+    /** `string` (a plain string arg), `value` (a tagged `Value`), or `comparison`. */
+    type: StatementSpec["rules"][number]["type"];
+    optional: boolean;
+    default?: string;
+    /**
+     * The field's closed set of legal values, where the engine declares one. Both
+     * a bare literal and the `c.text(...)` spelling are accepted, and a constant
+     * outside the set is rejected at authoring time.
+     */
+    enum?: string[];
+}
+/** One statement authoring surface. */
+interface ManifestStatement {
+    /** Canonical surface key (the engine schema basename), e.g. `array.filter`. */
+    surface: string;
+    /** Stored `mvp:` name emitted into the bundle. */
+    storedName: string;
+    /** Dotted accessor under `s`, e.g. `array.filter` → `s.array.filter`. */
+    sPath: string;
+    /** Whether the stored name has a registered factory (authorable today). */
+    registered: boolean;
+    /** True when generated from the engine schema (carries a field schema). */
+    declarative: boolean;
+    /** Whether the statement emits an `output` envelope. Declarative only. */
+    output?: boolean;
+    /**
+     * What the statement's `as:` output variable holds — so the manifest answers
+     * "what does this bind?" without falling back to prose. Curated (see
+     * `STATEMENT_RESULTS`); present only for statements whose result is stable and
+     * documented. Analogous to {@link ManifestFilter.result}, but structured: `name`
+     * is the binding field (always `as` today, carried explicitly so the descriptor
+     * is self-describing for machine consumers), `type` its value type, `note` an
+     * optional caveat.
+     */
+    result?: {
+        name: string;
+        type: string;
+        note?: string;
+    };
+    /** Field schema — present for declarative statements. */
+    fields?: ManifestField[];
+    /**
+     * An older paradigm the SDK still SUPPORTS but no longer wants authored — same
+     * contract as {@link ManifestValue.legacy}: withheld from the per-namespace
+     * catalog an agent picks from, and named-only in the legacy index (`llms/legacy.md`).
+     */
+    legacy?: boolean;
+}
+/**
+ * One authoring factory within a kind that fans out into several distinct
+ * root factories sharing a single encoder/payload key — today only `trigger`
+ * (six `obj_type`s, one shared stored envelope). Each sub-kind is a first-class
+ * root factory in its own right; the manifest lists them individually so agents
+ * treat them like every other primitive.
+ */
+interface ManifestSubKind {
+    /** Root authoring factory export, e.g. `tableTrigger`. */
+    authorFactory: string;
+    /** The stored `obj_type` this factory produces, e.g. `database`. */
+    objType: string;
+    /** Rich "what this primitive does" descriptor, in the style of a top-level kind. */
+    description: string;
+    /** Built and registered, but withheld from the published catalog — see {@link ManifestKind.unpublished}. */
+    unpublished?: boolean;
+    /**
+     * An older paradigm the SDK still SUPPORTS but no longer wants authored — same
+     * contract as {@link ManifestValue.legacy}: withheld from the sub-kind catalog
+     * and the trigger prose, and named-only in the legacy index (`llms/legacy.md`).
+     *
+     * Distinct from `unpublished`, which withholds a factory that is not ready.
+     * A legacy factory is fully ready and fully supported; it is the *paradigm*
+     * that has been superseded.
+     */
+    legacy?: boolean;
+}
+/** One top-level object kind. */
+interface ManifestKind {
+    /** Stable kind name, e.g. `function`. */
+    kind: string;
+    /** `packageExport` payload key, e.g. `function`, `dbo`. */
+    payloadKey: string;
+    /** Authoring factory export, e.g. `defineFunction`, `table`. */
+    authorFactory: string;
+    /** One-line "what this primitive does" descriptor, surfaced in `llms.txt`. */
+    description: string;
+    /** `Xano` registration method, e.g. `registerFunctions`. */
+    registerMethod: string;
+    /** Whether the kind has a registered encoder (implemented today). */
+    registered: boolean;
+    /**
+     * Distinct root factories that all persist under this kind's encoder/payload
+     * key. When present, the `## Object kinds` catalog lists each sub-kind as its
+     * own root-level entry instead of the grouped `authorFactory` line. Only
+     * `trigger` uses this today.
+     */
+    subKinds?: ManifestSubKind[];
+    /**
+     * Built and registered, but deliberately withheld from the published agent
+     * surface — kept out of the emitted manifest, out of `llms.txt`, and out of
+     * the coverage numerator.
+     *
+     * This is a *release* gate, not a completeness gate. The kind still has a
+     * descriptor here so the "descriptors match the live kind registry" drift
+     * guard keeps covering it; it just does not ship in the catalog yet. Flip the
+     * flag off to publish — nothing else needs to change.
+     */
+    unpublished?: boolean;
+}
+/** A value constructor / helper. */
+interface ManifestValue {
+    name: string;
+    signature: string;
+    description: string;
+    /**
+     * An older paradigm the SDK still SUPPORTS but no longer wants authored.
+     *
+     * Kept out of the `## Values` catalog — the list an agent picks from when it
+     * builds — and named-only in the legacy index (`llms/legacy.md`).
+     * That split is the whole point: hiding it entirely is worse than useless,
+     * because a pulled workspace can legitimately contain one, and an agent that
+     * has never heard of it will "fix" what it does not recognize. Naming it
+     * without a signature says "you will see this; do not reach for it."
+     */
+    legacy?: boolean;
+}
+/** One value-pipeline filter (`fl.<name>`). */
+interface ManifestFilter {
+    /** Filter name, as stored in the value `filters[]` chain. */
+    name: string;
+    /** Dotted accessor: `fl.<name>`. */
+    fl: string;
+    /**
+     * Whether the SDK knows this filter's exact signature.
+     *
+     * True for every filter with a spec — INCLUDING the zero-argument ones. A
+     * filter that takes nothing has nothing to type, so `fl.abs()` is as fully
+     * typed as `fl.add(value)`; counting it as untyped reported a 131/225 coverage
+     * gap that never existed. Whether a filter takes arguments is `args`, which is
+     * a different question and the one the catalog renders from.
+     */
+    typed: boolean;
+    /**
+     * Takes arguments the catalog declares no list for, so there is no arity to
+     * enforce and no signature to print. Distinct from a filter with neither
+     * `args` nor `variadic`, which takes NOTHING.
+     */
+    variadic?: boolean;
+    /**
+     * Named, typed args (richly-specified filters only). `enum` carries the exact
+     * accepted spellings where the arg has a closed set — printed in place of the
+     * bare word "enum", which told a reader nothing.
+     */
+    args?: Array<{
+        name: string;
+        type: string;
+        optional?: boolean;
+        enum?: string[];
+    }>;
+    /** Result type (richly-specified filters only). */
+    result?: string;
+    /** Group, e.g. `timestamp`, `vector` (richly-specified filters only). */
+    group?: string;
+    /** One-line description, when known. */
+    description?: string;
+}
+/** One field-catalog type (`f.<name>` / `input.<name>`). */
+interface ManifestFieldType {
+    /** Authoring constructor name under `f` / `input`, e.g. `text`, `tableRef`. */
+    name: string;
+    /** The stored type string emitted into the schema, e.g. `epochms`, `blob_img`. */
+    stored: string;
+    /** Valid bind-method names for this type (empty = none; `{name,arg}` escape hatch only). */
+    methods: string[];
+    /** Present and true when the type exists under `input.` only, with no `f.` column form. */
+    inputOnly?: boolean;
+}
+/** One CLI flag, with the effect it has. */
+interface ManifestCliFlag {
+    flag: string;
+    description: string;
+    /** The closed set the flag takes here — the same list shell completion offers. */
+    values?: string[];
+    /** For a flag that takes other values too: some it takes, never the whole set. */
+    examples?: string[];
+}
+/**
+ * One backend selector slot, from its declaration in the registry: where a
+ * command takes the backend it acts on, and which ones. The same declaration
+ * renders `--help`, completion, and the command's refusals, so an agent reading
+ * this learns exactly what the CLI will accept.
+ */
+interface ManifestCliSelector {
+    /** How the slot is written: `--from`, `--to`, `--on`, or the positional as `<source>`. */
+    slot: string;
+    role: SelectorSpec["role"];
+    /** Omitted: `tracked` = what this project last deployed to; `entry` = the project's entry file; `none` = nothing, name one. */
+    default: SelectorSpec["default"];
+    /** Every spelling the slot accepts, rendered. */
+    grammar: string;
+    /** The bare kinds, completable as typed. */
+    values: string[];
+    /** Kinds in the grammar this command cannot serve, each with why. */
+    refused?: Record<string, string>;
+}
+/**
+ * One CLI command, DERIVED from the `COMMANDS`/`FLAGS` registry in
+ * `src/emit/commands.ts` — the same table that renders `--help` and generates the
+ * shell completions.
+ *
+ * Derived, not hand-maintained: a hand-maintained copy drifts (missing commands,
+ * short flags, stale descriptions). Deriving it makes that class of drift
+ * unrepresentable, which matters because `llms.txt` does not document the CLI
+ * — this array and `--help` are the only two surfaces, and they are one source.
+ */
+interface ManifestCliCommand {
+    /** The invocation verb, e.g. `deploy`. */
+    command: string;
+    /** Positional argument grammar, when the command takes one. */
+    args?: string;
+    flags?: ManifestCliFlag[];
+    /** The command's backend selector slots, when it acts on a backend. */
+    selectors?: ManifestCliSelector[];
+    description: string;
+}
+interface Manifest {
+    name: string;
+    version: string;
+    description: string;
+    coverage: {
+        /**
+         * Counted over the ENGINE's object-kind catalog, where every trigger type is
+         * its own kind. `unmodeled` names the shortfall so the denominator is
+         * inspectable rather than a bare ratio.
+         */
+        objectKinds: {
+            implemented: number;
+            total: number;
+            unmodeled: {
+                kind: string;
+                absence: string;
+            }[];
+        };
+        /**
+         * `unconfirmed` names the statements built from the engine's schema alone,
+         * with no stored instance behind them — the same "make the denominator
+         * inspectable" move as `unmodeled` above, for a different kind of
+         * shortfall. Published as `s.` paths, because that is what an agent looks a
+         * statement up by. See `src/statements/byte-evidence.ts`.
+         */
+        statements: {
+            implemented: number;
+            total: number;
+            /**
+             * Omitted entirely when nothing is unconfirmed — an empty warning channel
+             * that ships on every build teaches a reader to skip the one time it has
+             * something in it.
+             */
+            unconfirmed?: {
+                note: string;
+                sPaths: string[];
+            };
+        };
+        filters: {
+            typed: number;
+            total: number;
+        };
+    };
+    values: {
+        constructors: ManifestValue[];
+        tags: readonly string[];
+    };
+    objectKinds: ManifestKind[];
+    fieldTypes: ManifestFieldType[];
+    statements: ManifestStatement[];
+    filters: ManifestFilter[];
+    /** The CLI command surface (compile/export/deploy/auth/lock). Hand-maintained. */
+    cli: ManifestCliCommand[];
+    /**
+     * Flags every command accepts. They appear in no per-command `flags` list, so
+     * without this they would be undiscoverable from the manifest alone — an agent
+     * reading `cli` would conclude `--json` does not exist.
+     */
+    cliGlobalFlags: ManifestCliFlag[];
+}
+/** Total engine object kinds — the size of the catalog above, never a literal. */
+declare const TOTAL_OBJECT_KINDS: number;
+/** Build the full authoring manifest from the SDK's sources of truth. */
+declare function buildManifest(opts?: {
+    version?: string;
+}): Manifest;
+/** Repo-relative path of the always-loaded grounding router. */
+declare const LLMS_TXT = "llms.txt";
+/**
+ * Every committed grounding artifact, as repo-relative path → content.
+ *
+ * The map is the seam the grounding surface is split across: the router at
+ * {@link LLMS_TXT} is what an agent always loads, and later entries are topic
+ * files it reads only when the surface they cover is in play. Callers write
+ * whatever the map holds rather than naming files individually, so a new
+ * artifact is picked up by the writer and by the drift guard without either
+ * needing to learn about it.
+ *
+ * Pure function of the manifest, like every other artifact here — regenerating
+ * is deterministic and the committed files are asserted against a fresh render.
+ */
+declare function renderDocs(m: Manifest): Map<string, string>;
+/** The router alone, for callers that want it without the rest of the set. */
+declare function renderLlmsTxt(m: Manifest): string;
+
+/**
+ * The cross-realm lock override store — how a `xano.lock` reaches `deriveGuid`.
+ *
+ * Reference guids are baked at AUTHORING time, not export time: statement
+ * factories (`s.function.run`, `s.db.get`, …) and even field defs
+ * (`f.tableRef`) call `resolveRef` → `deriveGuid` the moment the workspace
+ * module is evaluated, and some embed the guid inside strings (`dbo=<guid>`
+ * method args, auth-token const values). An export-time payload rewrite would
+ * have to chase those string-embedded forms — overriding at the `deriveGuid`
+ * choke point instead makes reference and target agree everywhere by
+ * construction, with zero changes at call sites.
+ *
+ * That yields the seeding contract: **seed once per process, BEFORE any
+ * def module is evaluated.** Node's module cache means seeding after defs have
+ * loaded is a silent no-op for already-baked references. The CLI honors this
+ * automatically (it seeds before importing the workspace entry); programmatic
+ * users must call `seedLockOverrides` before importing their defs.
+ * `resetLockOverrides` exists for tests (reset-then-seed per run).
+ *
+ * The store lives on `globalThis` under a `Symbol.for` key because the CLI and
+ * the workspace entry can load xanosdk in different module realms (the
+ * tsx-loader split — same reason `Xano.isXano` brands with `Symbol.for`). Every
+ * accessor goes through a fresh `globalThis` lookup, never a module-local
+ * reference, so both realms see one store.
+ */
+
+/**
+ * Seed the override store from a validated lock. Replaces any previous seed —
+ * the contract is one workspace per process (see module doc), so the CLI does
+ * reset-then-seed per run and multiple concurrent workspaces are out of scope.
+ */
+declare function seedLockOverrides(lock: LockFile): void;
+/** Clear the store (tests; a process about to seed a different workspace). */
+declare function resetLockOverrides(): void;
+/** True when a lock has been seeded in this process. */
+declare function isLockSeeded(): boolean;
+/** The locked guid for a `payloadKey:name` key, if the lock pins one. */
+declare function getLockedGuid(key: string): string | undefined;
+/** The locked canonical for a lock key, if the lock pins one. */
+declare function getLockedCanonical(key: string): string | undefined;
+
+export { registerSpec as $, type AmbientBindings as A, objectKeys as B, type CaptureValue as C, objectValues as D, type ElementResult as E, type FieldRule as F, type GroupedArrayResult as G, resetLockOverrides as H, type IteratingBindings as I, seedLockOverrides as J, textAppend as K, type LambdaOptions as L, type Manifest as M, textPrepend as N, type OutputAuthored as O, FILTER_NAMES as P, GENERATED_STATEMENT_NAMES as Q, type Route as R, type SameArrayResult as S, LLMS_TXT as T, TOTAL_OBJECT_KINDS as U, buildManifest as V, encodeFromSpec as W, generated as X, getLockedCanonical as Y, getLockedGuid as Z, isLockSeeded as _, type LambdaSurface as a, renderDocs as a0, renderLlmsTxt as a1, fl as a2, lam as a3, type CaptureRecord as b, type LambdaBindings as c, type Authored as d, type Capturable as e, type FilterResults as f, LAMBDA_BINDINGS as g, LAMBDA_CODE_FILTERS as h, LAMBDA_GLOBALS as i, LAMBDA_MODULE_GLOBALS as j, LAMBDA_STATEMENTS as k, type LambdaBody as l, type ManifestField as m, type ManifestKind as n, type ManifestStatement as o, type ManifestValue as p, type StatementSpec as q, assertLambdaBody as r, bitwiseAnd as s, bitwiseOr as t, bitwiseXor as u, mathAdd as v, mathDiv as w, mathMul as x, mathSub as y, objectEntries as z };