From 7ff7964213e5c7e5dca3e2171fc07a42aeb5404e Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 14:22:29 +0000
Subject: [PATCH 01/11] feat(spec): publish the typed hook `ctx.api` face from
 @objectstack/spec/data

Export `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`,
`HookUpdateOptions`, `HookDeleteOptions` and `HookUpdateDoc` so an app's
`*.hook.ts` imports the platform's type instead of re-deriving engine
semantics in its own copy.

Every option shape is derived from the `Engine*Options` schemas the engine's
own per-method legal-key sets are pinned against, and carries no `filter`
key: the engine folds `filter` into `where` and refuses the slot when the two
spellings disagree, so omitting the alias turns that hazard into a compile
error from the platform's own type.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 packages/spec/src/data/hook-api.test.ts | 210 ++++++++++++++++++
 packages/spec/src/data/hook-api.ts      | 278 ++++++++++++++++++++++++
 packages/spec/src/data/index.ts         |  10 +
 3 files changed, 498 insertions(+)
 create mode 100644 packages/spec/src/data/hook-api.test.ts
 create mode 100644 packages/spec/src/data/hook-api.ts

diff --git a/packages/spec/src/data/hook-api.test.ts b/packages/spec/src/data/hook-api.test.ts
new file mode 100644
index 00000000000..f5c77db697c
--- /dev/null
+++ b/packages/spec/src/data/hook-api.test.ts
@@ -0,0 +1,210 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#18163] The published hook `ctx.api` type face, pinned from both sides.
+ *
+ * Two independent things can go wrong with {@link HookApi}, and each leg below
+ * answers exactly one of them:
+ *
+ *  1. **It stops describing the object the engine binds.** Pinned as
+ *     assignability against `IScopedContext` — the CHECKED contract ObjectQL's
+ *     `ScopedContext` and `ObjectRepository` carry `implements` clauses
+ *     against. If `HookApi` ever declares a member or a return the checked
+ *     contract cannot satisfy, this file stops compiling.
+ *
+ *     ⚠️ NOT MEASURED HERE, by construction: that the CLASS `ScopedContext`
+ *     satisfies `HookApi`. `packages/spec` must not depend on
+ *     `packages/objectql` (only objectql can execute a dispatch, and spec is
+ *     the contract both sides read), so the class-vs-type leg belongs in
+ *     objectql beside `hook-input-shape-contract.test.ts`, which is where the
+ *     engine's other spec-contract pins live.
+ *
+ *  2. **The option bags drift from the engine's accepted vocabulary.** Every
+ *     shape is derived by `Omit`/`Pick` from the `Engine*Options` schemas the
+ *     engine's own per-method legal-key sets are pinned against
+ *     (`engine-unknown-option.test.ts` asserts each `ENGINE_*_OPTION_KEYS` set
+ *     equals its schema's shape). The runtime leg below pins each schema's key
+ *     set as KEPT ∪ OMITTED, so a seventh key added to a schema lands red here
+ *     until someone decides which side of the split it is on — the same
+ *     discipline the engine applies to `RPC_QUERY_ALIAS_SLOTS`.
+ *
+ * The `@ts-expect-error` pins are real checks here: `tsconfig.test.json`
+ * compiles this layer (`pnpm --filter @objectstack/spec check:test-typecheck`),
+ * so deleting a directive turns the gate red rather than leaving it green.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import {
+  EngineCountOptionsSchema,
+  EngineDeleteOptionsSchema,
+  EngineQueryOptionsSchema,
+  EngineUpdateOptionsSchema,
+} from './data-engine.zod';
+import type {
+  HookApi,
+  HookCountQuery,
+  HookDeleteOptions,
+  HookObjectApi,
+  HookQuery,
+  HookUpdateOptions,
+} from './hook-api';
+import type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';
+
+/** `true` only when every `A` is a usable `B`. */
+type Assignable<A, B> = [A] extends [B] ? true : false;
+
+const shapeKeys = (schema: unknown): string[] =>
+  Object.keys((schema as { shape: Record<string, unknown> }).shape).sort();
+
+describe('HookApi — the published hook ctx.api face', () => {
+  describe('stays a usable IScopedContext', () => {
+    it('HookApi satisfies the checked implementation contract', () => {
+      const apiIsAScopedContext: Assignable<HookApi, IScopedContext> = true;
+      const repoIsAScopedRepository: Assignable<HookObjectApi, IScopedObjectRepository> = true;
+      expect([apiIsAScopedContext, repoIsAScopedRepository]).toEqual([true, true]);
+    });
+
+    it('a hook can narrow ctx.api to it without going through `unknown`', () => {
+      // The authoring idiom the export exists for. `HookContext['api']` is
+      // `IScopedContext | undefined`; this cast has to stay legal, so the two
+      // faces must remain COMPARABLE — a direct `as` here, never `as unknown as`.
+      const ctxApi = undefined as unknown as IScopedContext | undefined;
+      const api = ctxApi as HookApi | undefined;
+      expect(api).toBeUndefined();
+    });
+  });
+
+  describe('the where-only rule', () => {
+    it('accepts the canonical spellings', () => {
+      const query: HookQuery = {
+        where: { status: 'active' },
+        fields: ['id', 'name'],
+        orderBy: [{ field: 'name', order: 'asc' }],
+        limit: 10,
+        offset: 20,
+      };
+      expect(Object.keys(query).sort()).toEqual(
+        ['fields', 'limit', 'offset', 'orderBy', 'where'].sort(),
+      );
+    });
+
+    it('refuses the alias spellings at compile time', () => {
+      const withFilter: HookQuery = {
+        where: { status: 'active' },
+        // @ts-expect-error `filter` is the ALIAS of `where`. The engine folds
+        // the slot and throws when the two spellings carry different values;
+        // omitting the key makes that hazard a compile error instead.
+        filter: { status: 'won' },
+      };
+      const withTop: HookQuery = {
+        limit: 3,
+        // @ts-expect-error `top` is the OData alias of `limit`, folded by the
+        // same slot table and refused on the same value disagreement.
+        top: 1,
+      };
+      const withContext: HookQuery = {
+        where: { id: 'a' },
+        // @ts-expect-error the repository INJECTS `context` after the spread,
+        // so a caller-supplied one is discarded before the engine sees it.
+        context: { isSystem: true },
+      };
+      expect([withFilter, withTop, withContext].length).toBe(3);
+    });
+
+    it('refuses the wire-only spellings the engine rejects at the entry point', () => {
+      const wireOnly: HookQuery = {
+        // @ts-expect-error `select` is the wire spelling of `fields`; a direct
+        // engine call bypasses the RPC fold, so the engine rejects it by name.
+        select: ['id'],
+      };
+      expect(wireOnly).toBeTruthy();
+    });
+  });
+
+  describe('count is not find narrowed by habit', () => {
+    it('takes `where` and refuses everything else', () => {
+      const ok: HookCountQuery = { where: { status: 'active' } };
+      const withLimit: HookCountQuery = {
+        // @ts-expect-error `count` honours no pagination — `ENGINE_COUNT_OPTION_KEYS`
+        // is `{ context, where }` and the engine rejects anything else.
+        limit: 5,
+      };
+      const withPassthrough: HookCountQuery = {
+        // @ts-expect-error `count` never forwards its bag to the driver, so the
+        // pass-through keys that ARE legal on find/update/delete are rejected here.
+        tenantId: 'org_1',
+      };
+      expect([ok, withLimit, withPassthrough].length).toBe(3);
+    });
+  });
+
+  describe('write option bags', () => {
+    it('update carries the predicate form, the observability keys and the pass-throughs', () => {
+      const bulk: HookUpdateOptions = {
+        where: { status: 'draft' },
+        multi: true,
+        returning: true,
+        strictReadonlyWrites: true,
+        onFieldsDropped: (event) => void event.fields,
+        tenantId: 'org_1',
+      };
+      const retired: HookUpdateOptions = {
+        // @ts-expect-error `upsert` is a retired-key tombstone (#8057). It stays
+        // on the schema to carry its migration text, never on a surface
+        // published after the retirement.
+        upsert: true,
+      };
+      expect([bulk, retired].length).toBe(2);
+    });
+
+    it('delete carries the predicate form and no update-only keys', () => {
+      const ok: HookDeleteOptions = { where: { status: 'stale' }, multi: true };
+      const wrong: HookDeleteOptions = {
+        where: { id: 'a' },
+        // @ts-expect-error `returning` is an UPDATE option; the engine's delete
+        // set is `{ context, where, multi }` plus the pass-throughs.
+        returning: true,
+      };
+      expect([ok, wrong].length).toBe(2);
+    });
+  });
+
+  describe('drift pin — each derived shape equals KEPT ∪ OMITTED on its schema', () => {
+    // Restated here on purpose rather than imported: a schema key added later
+    // has to be DECIDED onto one of the two lists, and this pin is what forces
+    // the decision instead of letting `Omit` silently widen the published type.
+    const cases: { name: string; schema: unknown; kept: string[]; omitted: string[] }[] = [
+      {
+        name: 'HookQuery / EngineQueryOptionsSchema',
+        schema: EngineQueryOptionsSchema,
+        kept: ['where', 'fields', 'orderBy', 'limit', 'offset', 'search', 'searchFields', 'expand'],
+        omitted: ['context', 'top', 'cursor', 'distinct'],
+      },
+      {
+        name: 'HookCountQuery / EngineCountOptionsSchema',
+        schema: EngineCountOptionsSchema,
+        kept: ['where'],
+        omitted: ['context'],
+      },
+      {
+        name: 'HookUpdateOptions / EngineUpdateOptionsSchema',
+        schema: EngineUpdateOptionsSchema,
+        kept: ['where', 'multi', 'returning'],
+        omitted: ['context', 'upsert'],
+      },
+      {
+        name: 'HookDeleteOptions / EngineDeleteOptionsSchema',
+        schema: EngineDeleteOptionsSchema,
+        kept: ['where', 'multi'],
+        omitted: ['context'],
+      },
+    ];
+
+    for (const { name, schema, kept, omitted } of cases) {
+      it(name, () => {
+        expect(shapeKeys(schema)).toEqual([...kept, ...omitted].sort());
+      });
+    }
+  });
+});
diff --git a/packages/spec/src/data/hook-api.ts b/packages/spec/src/data/hook-api.ts
new file mode 100644
index 00000000000..c3165c0ed22
--- /dev/null
+++ b/packages/spec/src/data/hook-api.ts
@@ -0,0 +1,278 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * `HookApi` — the typed AUTHORING face of `HookContext.api`, published from
+ * `@objectstack/spec/data` so an app's `*.hook.ts` never has to re-derive it.
+ *
+ * ## Why this exists (#18163, maintainer ruling A of 2026-09-17, batch #147)
+ *
+ * The platform already implements this surface; it just never published a type
+ * an app could import. So every metadata app hand-declared one — the reference
+ * third-party app carried ~2,358 authored tokens of it in one file, imported by
+ * 17 hook files — and a hand-declared copy of an engine's option vocabulary
+ * drifts silently the moment the engine moves. The ruling reads that as a
+ * STABILITY item, not a feature: one source of truth for engine semantics.
+ *
+ * ## What it is NOT: a second dialect of `IScopedContext`
+ *
+ * `contracts/scoped-context.ts` declares {@link IScopedContext} — the CHECKED
+ * IMPLEMENTATION contract. ObjectQL's `ScopedContext` (the class the engine
+ * builds at every hook dispatch, `buildHookApi`) and its `ObjectRepository`
+ * carry `implements` clauses against it, so it is verified on every objectql
+ * build. Its option bags are deliberately `Record<string, unknown>`, and that
+ * file argues at length why: typing them with the engine's own option types
+ * would make an object literal spelling `filter` a compile error over a call
+ * the runtime accepts, because the engine folds `filter` to `where`.
+ *
+ * This file is the OTHER half of the same fact, and the ruling is what settles
+ * the trade-off the older file left open:
+ *
+ *   - `IScopedContext` answers "what members does the object the engine binds
+ *     have?" — evidence-barred, loose in the bags, wired to `implements`.
+ *   - `HookApi` answers "what may a hook author WRITE into those bags?" — the
+ *     canonical spelling only, so the `where`/`filter` mixing hazard is a
+ *     compile error FROM THE PLATFORM'S OWN TYPE instead of a runtime throw.
+ *
+ * They do not drift, because every option shape below is DERIVED from the very
+ * `Engine*Options` schemas the engine's own per-method legal-key sets are
+ * pinned against (`ENGINE_OPTION_KEY_SETS` in `packages/objectql/src/engine.ts`,
+ * drift-pinned in `engine-unknown-option.test.ts`). A key added to a schema
+ * flows into the type the same run it flows into the engine's accepted set.
+ * `hook-api.test.ts` pins the relationship in both directions.
+ *
+ * ## The `where`-only rule, measured
+ *
+ * `RPC_QUERY_ALIAS_SLOTS` (`data/data-engine.zod.ts`) declares `filter` as the
+ * alias of `where` and `top` as the alias of `limit`. Every engine entry point
+ * folds the `where` slot; the find-shaped ones (`find`/`findOne`) additionally
+ * fold `limit`. `foldQueryAliasSlots` collapses redundant IDENTICAL spellings
+ * and REFUSES a slot whose spellings carry DIFFERENT values — the engine turns
+ * that conflict into a throw naming both spellings. So `{ where, filter }` is
+ * a coin toss decided by whether the two happen to be deep-equal: silent when
+ * they agree, a runtime error when they do not.
+ *
+ * Omitting the alias keys from these types is what makes it neither. It is the
+ * ruling's explicit instruction for `filter`, and the SAME measurement carries
+ * `top`: both are alias spellings of a canonical key, both throw on a value
+ * disagreement, neither adds any expressive power. Authors spell `where` and
+ * `limit`. ⚠️ REVIEW POINT — the ruling names `filter`; extending it to `top`
+ * is this file's reading of the same rule, and is the one place a reviewer
+ * should decide whether the type should be wider than the ruling's letter.
+ *
+ * ## What else is deliberately off the bags, each with its reason
+ *
+ *   - `context` — the repository INJECTS it (`{ ...query, context: this.context }`,
+ *     spread last), so a caller-supplied `context` is overwritten before the
+ *     engine sees it. Declaring a key the seam discards is the declared-≠-enforced
+ *     shape AGENTS.md PD #10 refuses.
+ *   - `cursor` / `distinct` / `upsert` — `retiredKey()` tombstones. They stay on
+ *     the schemas to carry their migration text; the engine rejects them by
+ *     quoting that text. They are not part of an authoring surface published
+ *     after their retirement.
+ *   - `sudo()` — the #5945 exclusion STANDS. It is privilege escalation, no
+ *     document teaches it as first-hook vocabulary, and since #14010 the
+ *     declared way for a hook to run elevated is `Hook.runAs: 'system'`, which
+ *     the engine applies to this very `api`. Publishing it here would be a
+ *     maintainer decision, not a measurement.
+ *   - `aggregate` / `execute` / `create` / `deleteById` on the repository. Real
+ *     methods on the class, outside what this ruling asked to publish;
+ *     `execute` additionally dispatches ELEVATED (`{ ...context, isSystem: true }`,
+ *     #13866), which puts it in `sudo()`'s register rather than the CRUD one.
+ *     They join when a ruling or a measured call site says so.
+ */
+
+import type {
+  EngineCountOptions,
+  EngineDeleteOptions,
+  EngineQueryOptions,
+  EngineUpdateOptions,
+} from './data-engine.zod';
+import type { DriverOptions } from './driver.zod';
+// Type-only, and it must stay that way, for the reason `hook.zod.ts` states at
+// its own `contracts/` import: `contracts/` already imports `data/`, so a VALUE
+// import here would close a runtime cycle. `import type` is erased.
+import type { WriteObservabilityOptions } from '../contracts/data-engine';
+import type {
+  EngineTransactionInfo,
+  EngineTransactionOptions,
+} from '../contracts/objectql-engine';
+
+/**
+ * The driver-option keys the engine forwards VERBATIM from a read/write option
+ * bag into the driver options — `ENGINE_DRIVER_PASSTHROUGH_KEYS` in
+ * `packages/objectql/src/engine.ts`, reused from {@link DriverOptions} rather
+ * than re-spelled so there is one declaration of each key's type.
+ *
+ * ⚠️ They are legal on `find` / `findOne` / `update` / `delete` and NOT on
+ * `count`, which forwards no bag at all and whose legal set is `where` alone.
+ * That asymmetry is engine behaviour, it is invisible from any document, and it
+ * is precisely the kind of thing a hand-written copy gets wrong — which is why
+ * {@link HookCountQuery} below is the one shape that does not carry these.
+ *
+ * `bypassTenantAudit` is diagnostics-only by declaration ("never changes what
+ * the write touches") and `preserveAudit` covers historical imports; neither is
+ * an authorization switch, so unlike `sudo()` they are ordinary declared
+ * vocabulary rather than an escalation this surface would be advertising.
+ */
+export type HookDriverPassthroughOptions = Pick<
+  DriverOptions,
+  'transaction' | 'tenantId' | 'tenantIds' | 'timezone' | 'bypassTenantAudit' | 'preserveAudit'
+>;
+
+/**
+ * The query bag `ctx.api.object(n).find()` / `.findOne()` accept.
+ *
+ * `EngineQueryOptions` minus the injected `context`, minus the `top` alias and
+ * minus the two tombstones, plus the driver pass-through keys the engine
+ * forwards. There is NO `filter` key — spell the predicate `where`.
+ *
+ * `findOne` additionally REFUSES an unpredicated query at runtime (#4419): it
+ * reads a single row, so an empty predicate answers the object's FIRST row
+ * rather than nothing. Say which row you want with `where`, a `search`, or an
+ * `orderBy`; when any row will do, that is `find({ limit: 1 })`.
+ */
+export type HookQuery = Omit<EngineQueryOptions, 'context' | 'top' | 'cursor' | 'distinct'> &
+  HookDriverPassthroughOptions;
+
+/**
+ * The query bag `ctx.api.object(n).count()` accepts — `where` and nothing else.
+ *
+ * ⛔ Not {@link HookQuery} narrowed by habit: `count` never forwards its bag to
+ * the driver, so the pass-through keys that are legal on every other method are
+ * REJECTED here (`ENGINE_COUNT_OPTION_KEYS` is `{ context, where }`), and so are
+ * `limit` / `orderBy` / `fields`, which a count honours nowhere.
+ */
+export type HookCountQuery = Omit<EngineCountOptions, 'context'>;
+
+/** A record payload a hook write carries. */
+export type HookDoc = Record<string, unknown>;
+
+/**
+ * The payload `update` / `updateById` take.
+ *
+ * The single-record `update` form puts the primary key INSIDE the payload —
+ * `update({ id, ...fieldsToChange })` — because the repository reads the key
+ * out of it. `updateById` takes the id as its own first argument instead.
+ */
+export type HookUpdateDoc = HookDoc;
+
+/**
+ * The options bag `ctx.api.object(n).update()` accepts.
+ *
+ * `EngineUpdateOptions` minus the injected `context` and the `upsert`
+ * tombstone, plus {@link WriteObservabilityOptions} (`onFieldsDropped`,
+ * `strictReadonlyWrites` — contract-declared, deliberately outside the
+ * serializable schema) and the driver pass-through keys.
+ *
+ * The bulk form is `update(data, { where, multi: true })`; there is no
+ * `updateMany`.
+ */
+export type HookUpdateOptions = Omit<EngineUpdateOptions, 'context' | 'upsert'> &
+  WriteObservabilityOptions &
+  HookDriverPassthroughOptions;
+
+/** The options bag `ctx.api.object(n).delete()` accepts. */
+export type HookDeleteOptions = Omit<EngineDeleteOptions, 'context'> &
+  HookDriverPassthroughOptions;
+
+/**
+ * A repository bound to ONE object and to the calling hook's execution context
+ * — what `ctx.api.object(name)` hands back.
+ *
+ * Scoping is the point: a write through here goes down the engine's normal
+ * path and is therefore gated by the TARGET object's permission and sharing
+ * rules, not by whoever happens to be elevated.
+ *
+ * Every return shape below MIRRORS the declaration the platform already
+ * publishes for the same seam — `IScopedObjectRepository` where it declares the
+ * member, `IDataEngine` where it does not (`delete`) — rather than answering
+ * the same question a second way.
+ */
+export interface HookObjectApi {
+  /**
+   * Read every record the query selects.
+   *
+   * `Promise<any[]>` mirrors `IScopedObjectRepository.find` and
+   * `IDataEngine.find`; narrowing it here would make this face disagree with
+   * the two declarations it forwards through.
+   */
+  find(query?: HookQuery): Promise<any[]>;
+
+  /** Read the ONE record the query selects, or `null`. */
+  findOne(query?: HookQuery): Promise<Record<string, any> | null>;
+
+  /** Count the records the query selects. */
+  count(query?: HookCountQuery): Promise<number>;
+
+  /** Insert one record, or an array of records. */
+  insert(data: HookDoc | HookDoc[]): Promise<any>;
+
+  /**
+   * Update records: the record for the single-record form, the affected-row
+   * count for the predicate form (`{ where, multi: true }`), `null` when the
+   * write matched nothing.
+   */
+  update(
+    data: HookUpdateDoc,
+    options?: HookUpdateOptions,
+  ): Promise<Record<string, any> | number | null>;
+
+  /**
+   * Update a single record by id — the id travels as the first argument.
+   *
+   * Answers the written record, or `null` when the id matched nothing. A falsy
+   * id is not a narrower answer but a REFUSAL: `0` and `''` identify no row, so
+   * the dispatch rejects and the call throws.
+   */
+  updateById(id: string | number, data: HookUpdateDoc): Promise<Record<string, any> | null>;
+
+  /**
+   * Delete records — `{ where, multi: true }` for the predicate form.
+   *
+   * `Promise<boolean | number>` is what `IDataEngine.delete` declares, one door
+   * down from this method.
+   */
+  delete(options?: HookDeleteOptions): Promise<boolean | number>;
+}
+
+/**
+ * The scoped cross-object API a hook reaches through `ctx.api`.
+ *
+ * It carries NO top-level `insert` / `update` / `find`: a caller names the
+ * object first and operates on the repository that comes back
+ * (`ctx.api.object('task').insert(…)`), which is what makes the scoping
+ * legible — every operation is addressed to a named object.
+ *
+ * `ctx.api` is declared `IScopedContext | undefined` on `HookContext`, so a
+ * hook narrows to this face at the top of its handler:
+ *
+ * ```ts
+ * import type { HookApi } from '@objectstack/spec/data';
+ *
+ * const api = ctx.api as HookApi | undefined;
+ * if (!api) return;
+ * const owner = await api.object('user').findOne({ where: { id: ctx.input.owner } });
+ * ```
+ */
+export interface HookApi {
+  /** The repository for `name`, bound to this context. */
+  object(name: string): HookObjectApi;
+
+  /**
+   * Run `callback` inside one driver transaction: committed when it returns,
+   * rolled back when it throws.
+   *
+   * The callback receives a NEW `HookApi` whose operations share the
+   * transaction handle — reach objects through THAT context (`tx.object(…)`),
+   * not the outer one, or the writes land outside the transaction.
+   *
+   * The second parameter is declared because the PRODUCER hands it
+   * unconditionally (`ScopedContext.transaction`, #5696). Contravariance keeps
+   * the zero- and one-argument callbacks authors actually write assignable, so
+   * the truthful signature is also the more permissive one.
+   */
+  transaction<T>(
+    callback: (trxCtx: HookApi, info: EngineTransactionInfo) => Promise<T>,
+    opts?: EngineTransactionOptions,
+  ): Promise<T>;
+}
diff --git a/packages/spec/src/data/index.ts b/packages/spec/src/data/index.ts
index f9a26ff5ab3..6fff4c17ccf 100644
--- a/packages/spec/src/data/index.ts
+++ b/packages/spec/src/data/index.ts
@@ -150,6 +150,16 @@ export * from './autonumber-format';
 export * from './validation.zod';
 export * from './hook.zod';
 export * from './hook-body.zod';
+// [#18163] The TYPED AUTHORING FACE of `HookContext.api` — `HookApi`,
+// `HookObjectApi` and the query / count / update / delete option shapes the
+// engine actually accepts. `contracts/scoped-context.ts` declares the CHECKED
+// IMPLEMENTATION contract the engine's `ScopedContext` carries an `implements`
+// clause against, with deliberately loose `Record<string, unknown>` bags; this
+// is the other half — the same seam with the engine's own option vocabulary,
+// derived from the `Engine*Options` schemas so the two cannot drift, and
+// carrying NO `filter` key, so the `where`/`filter` mixing the engine refuses
+// on a value disagreement is a compile error instead of a runtime throw.
+export * from './hook-api';
 // The bulk-write hook dispatch contract (ADR-0058 Addendum II) — what a
 // predicate (`multi: true`) write hands a lifecycle hook in BOTH phases: per-row
 // dispatch, per-row `previous`, a batch-scoped payload, and one budget ceiling

From 83d93156aacb982300211c95cf885ed7348e0d1c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 14:28:50 +0000
Subject: [PATCH 02/11] chore(spec): regenerate the api-surface, declarations
 and export-origins artifacts

Nine additive exported names from `@objectstack/spec/data`; no removals
(exported names 832 -> 841, declarations 845 -> 854).

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../spec/api-surface-declarations/data.txt    | 84 ++++++++++++++++++-
 packages/spec/api-surface/data.json           |  9 ++
 packages/spec/export-origins/data.json        |  9 ++
 3 files changed, 100 insertions(+), 2 deletions(-)

diff --git a/packages/spec/api-surface-declarations/data.txt b/packages/spec/api-surface-declarations/data.txt
index bdf043b1be4..50367239f8f 100644
--- a/packages/spec/api-surface-declarations/data.txt
+++ b/packages/spec/api-surface-declarations/data.txt
@@ -12,8 +12,8 @@
 # excluded: documentation drift is `check:docs`'s axis, not this one.
 #
 # entry: ./data
-# exported names: 832
-# declarations: 845
+# exported names: 841
+# declarations: 854
 #
 # GENERATED — ⛔ never hand-edited. Regenerate after a real build:
 #   pnpm --filter @objectstack/spec build && pnpm --filter @objectstack/spec gen:api-surface-declarations
@@ -14285,6 +14285,26 @@ declare const GroupByNodeSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
 // ── Hook (type) ──
 type Hook = z.input<typeof HookSchema>;
 
+// ── HookApi (interface) ──
+interface HookApi {
+    /** The repository for `name`, bound to this context. */
+    object(name: string): HookObjectApi;
+    /**
+     * Run `callback` inside one driver transaction: committed when it returns,
+     * rolled back when it throws.
+     *
+     * The callback receives a NEW `HookApi` whose operations share the
+     * transaction handle — reach objects through THAT context (`tx.object(…)`),
+     * not the outer one, or the writes land outside the transaction.
+     *
+     * The second parameter is declared because the PRODUCER hands it
+     * unconditionally (`ScopedContext.transaction`, #5696). Contravariance keeps
+     * the zero- and one-argument callbacks authors actually write assignable, so
+     * the truthful signature is also the more permissive one.
+     */
+    transaction<T>(callback: (trxCtx: HookApi, info: EngineTransactionInfo) => Promise<T>, opts?: EngineTransactionOptions): Promise<T>;
+}
+
 // ── HookBody (type) ──
 type HookBody = z.input<typeof HookBodySchema>;
 
@@ -14379,9 +14399,21 @@ declare const HookContextSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
+// ── HookCountQuery (type) ──
+type HookCountQuery = Omit<EngineCountOptions, 'context'>;
+
+// ── HookDeleteOptions (type) ──
+type HookDeleteOptions = Omit<EngineDeleteOptions, 'context'> & HookDriverPassthroughOptions;
+
 // ── HookDispatch (type) ──
 type HookDispatch = NonNullable<HookContext['dispatch']>;
 
+// ── HookDoc (type) ──
+type HookDoc = Record<string, unknown>;
+
+// ── HookDriverPassthroughOptions (type) ──
+type HookDriverPassthroughOptions = Pick<DriverOptions, 'transaction' | 'tenantId' | 'tenantIds' | 'timezone' | 'bypassTenantAudit' | 'preserveAudit'>;
+
 // ── HookEvent (const) ──
 declare const HookEvent: z.ZodEnum<{
     beforeInsert: "beforeInsert";
@@ -14397,9 +14429,51 @@ declare const HookEvent: z.ZodEnum<{
 // ── HookEventType (type) ──
 type HookEventType = z.input<typeof HookEvent>;
 
+// ── HookObjectApi (interface) ──
+interface HookObjectApi {
+    /**
+     * Read every record the query selects.
+     *
+     * `Promise<any[]>` mirrors `IScopedObjectRepository.find` and
+     * `IDataEngine.find`; narrowing it here would make this face disagree with
+     * the two declarations it forwards through.
+     */
+    find(query?: HookQuery): Promise<any[]>;
+    /** Read the ONE record the query selects, or `null`. */
+    findOne(query?: HookQuery): Promise<Record<string, any> | null>;
+    /** Count the records the query selects. */
+    count(query?: HookCountQuery): Promise<number>;
+    /** Insert one record, or an array of records. */
+    insert(data: HookDoc | HookDoc[]): Promise<any>;
+    /**
+     * Update records: the record for the single-record form, the affected-row
+     * count for the predicate form (`{ where, multi: true }`), `null` when the
+     * write matched nothing.
+     */
+    update(data: HookUpdateDoc, options?: HookUpdateOptions): Promise<Record<string, any> | number | null>;
+    /**
+     * Update a single record by id — the id travels as the first argument.
+     *
+     * Answers the written record, or `null` when the id matched nothing. A falsy
+     * id is not a narrower answer but a REFUSAL: `0` and `''` identify no row, so
+     * the dispatch rejects and the call throws.
+     */
+    updateById(id: string | number, data: HookUpdateDoc): Promise<Record<string, any> | null>;
+    /**
+     * Delete records — `{ where, multi: true }` for the predicate form.
+     *
+     * `Promise<boolean | number>` is what `IDataEngine.delete` declares, one door
+     * down from this method.
+     */
+    delete(options?: HookDeleteOptions): Promise<boolean | number>;
+}
+
 // ── HookParsed (type) ──
 type HookParsed = z.infer<typeof HookSchema>;
 
+// ── HookQuery (type) ──
+type HookQuery = Omit<EngineQueryOptions, 'context' | 'top' | 'cursor' | 'distinct'> & HookDriverPassthroughOptions;
+
 // ── HookSchema (const) ──
 declare const HookSchema: z.ZodObject<{
     _lock: z.ZodOptional<z.ZodEnum<{
@@ -14493,6 +14567,12 @@ declare const HookSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 
+// ── HookUpdateDoc (type) ──
+type HookUpdateDoc = HookDoc;
+
+// ── HookUpdateOptions (type) ──
+type HookUpdateOptions = Omit<EngineUpdateOptions, 'context' | 'upsert'> & WriteObservabilityOptions & HookDriverPassthroughOptions;
+
 // ── IMPORT_BOOLEAN_FALSE_TOKENS (const) ──
 declare const IMPORT_BOOLEAN_FALSE_TOKENS: ReadonlySet<string>;
 
diff --git a/packages/spec/api-surface/data.json b/packages/spec/api-surface/data.json
index 70a13d7299f..b2de72b8713 100644
--- a/packages/spec/api-surface/data.json
+++ b/packages/spec/api-surface/data.json
@@ -337,6 +337,7 @@
     "GroupByNode (type)",
     "GroupByNodeSchema (const)",
     "Hook (type)",
+    "HookApi (interface)",
     "HookBody (type)",
     "HookBodyCapability (const)",
     "HookBodyCapability (type)",
@@ -344,11 +345,19 @@
     "HookBodySchema (const)",
     "HookContext (type)",
     "HookContextSchema (const)",
+    "HookCountQuery (type)",
+    "HookDeleteOptions (type)",
     "HookDispatch (type)",
+    "HookDoc (type)",
+    "HookDriverPassthroughOptions (type)",
     "HookEvent (const)",
     "HookEventType (type)",
+    "HookObjectApi (interface)",
     "HookParsed (type)",
+    "HookQuery (type)",
     "HookSchema (const)",
+    "HookUpdateDoc (type)",
+    "HookUpdateOptions (type)",
     "IMPORT_BOOLEAN_FALSE_TOKENS (const)",
     "IMPORT_BOOLEAN_TRUE_TOKENS (const)",
     "IMPORT_REFERENCE_TYPES (const)",
diff --git a/packages/spec/export-origins/data.json b/packages/spec/export-origins/data.json
index 6cc002ebaa0..870c4c6c344 100644
--- a/packages/spec/export-origins/data.json
+++ b/packages/spec/export-origins/data.json
@@ -328,17 +328,26 @@
     "GroupByNode": "src/data/query.zod.ts#GroupByNode (type)",
     "GroupByNodeSchema": "src/data/query.zod.ts#GroupByNodeSchema (const)",
     "Hook": "src/data/hook.zod.ts#Hook (type)",
+    "HookApi": "src/data/hook-api.ts#HookApi (interface)",
     "HookBody": "src/data/hook-body.zod.ts#HookBody (type)",
     "HookBodyCapability": "src/data/hook-body.zod.ts#HookBodyCapability (type)",
     "HookBodyParsed": "src/data/hook-body.zod.ts#HookBodyParsed (type)",
     "HookBodySchema": "src/data/hook-body.zod.ts#HookBodySchema (const)",
     "HookContext": "src/data/hook.zod.ts#HookContext (type)",
     "HookContextSchema": "src/data/hook.zod.ts#HookContextSchema (const)",
+    "HookCountQuery": "src/data/hook-api.ts#HookCountQuery (type)",
+    "HookDeleteOptions": "src/data/hook-api.ts#HookDeleteOptions (type)",
     "HookDispatch": "src/data/hook.zod.ts#HookDispatch (type)",
+    "HookDoc": "src/data/hook-api.ts#HookDoc (type)",
+    "HookDriverPassthroughOptions": "src/data/hook-api.ts#HookDriverPassthroughOptions (type)",
     "HookEvent": "src/data/hook.zod.ts#HookEvent (const)",
     "HookEventType": "src/data/hook.zod.ts#HookEventType (type)",
+    "HookObjectApi": "src/data/hook-api.ts#HookObjectApi (interface)",
     "HookParsed": "src/data/hook.zod.ts#HookParsed (type)",
+    "HookQuery": "src/data/hook-api.ts#HookQuery (type)",
     "HookSchema": "src/data/hook.zod.ts#HookSchema (const)",
+    "HookUpdateDoc": "src/data/hook-api.ts#HookUpdateDoc (type)",
+    "HookUpdateOptions": "src/data/hook-api.ts#HookUpdateOptions (type)",
     "IMPORT_BOOLEAN_FALSE_TOKENS": "src/data/import-coercion.ts#IMPORT_BOOLEAN_FALSE_TOKENS (const)",
     "IMPORT_BOOLEAN_TRUE_TOKENS": "src/data/import-coercion.ts#IMPORT_BOOLEAN_TRUE_TOKENS (const)",
     "IMPORT_REFERENCE_TYPES": "src/data/import-coercion.ts#IMPORT_REFERENCE_TYPES (const)",

From 09f22fbdc42176fcd63af3dbd86f617a7376e7a0 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 14:49:26 +0000
Subject: [PATCH 03/11] chore(changeset): minor for the published hook ctx.api
 type face
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Clause-②: yes (widening)

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/18163-export-hook-api-types.md | 24 +++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .changeset/18163-export-hook-api-types.md

diff --git a/.changeset/18163-export-hook-api-types.md b/.changeset/18163-export-hook-api-types.md
new file mode 100644
index 00000000000..0688ad57bac
--- /dev/null
+++ b/.changeset/18163-export-hook-api-types.md
@@ -0,0 +1,24 @@
+---
+'@objectstack/spec': minor
+---
+
+`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163).
+
+```ts
+import type { HookApi } from '@objectstack/spec/data';
+
+const api = ctx.api as HookApi | undefined;
+if (!api) return;
+const owner = await api.object('user').findOne({ where: { id: ctx.input.owner } });
+```
+
+The platform already implemented this surface; it just never published a type an app could import, so every app re-derived the engine's option vocabulary in a copy that drifts the moment the engine moves. The reference third-party app carried ~2,358 authored tokens of one in a single file, imported by 17 hook files.
+
+- **The query shape is `where`-only — there is no `filter` key, deliberately.** `RPC_QUERY_ALIAS_SLOTS` declares `filter` as the alias of `where` (and `top` as the alias of `limit`); every engine entry point folds the `where` slot, collapsing redundant identical spellings and REFUSING the slot when the two spellings carry different values. So `{ where, filter }` is silent when they happen to agree and a runtime throw when they do not. Omitting the alias keys makes it neither: `TS2353: 'filter' does not exist in type 'HookQuery'`, at the authoring site.
+- **Not a second dialect of `IScopedContext`.** `contracts/scoped-context.ts` stays the CHECKED IMPLEMENTATION contract ObjectQL's `ScopedContext` and `ObjectRepository` carry `implements` clauses against, with its deliberately loose `Record<string, unknown>` bags. This is the authoring half of the same seam: `HookApi` is assignable to `IScopedContext`, so `ctx.api as HookApi` stays a direct cast, and nothing about the older contract changes.
+- **Every option shape is DERIVED, not transcribed.** Each is an `Omit`/`Pick` over the `Engine*Options` schemas that the engine's own per-method legal-key sets are pinned against, so a key added to a schema reaches the published type in the same run it reaches the engine's accepted set. `count` is the one shape without the driver pass-through keys, because the engine forwards no bag on that method and rejects them there — engine behaviour no document states, and exactly what a hand-written copy gets wrong.
+- **What is deliberately absent, each for a stated reason**: `context` (the repository injects it and discards a caller's), the `cursor` / `distinct` / `upsert` tombstones, `sudo()` (the #5945 exclusion stands — `Hook.runAs: 'system'` is the declared way to run elevated), and `aggregate` / `execute` / `create` / `deleteById`.
+
+Additive only: nine new exported names from `./data`, no removal and no signature change, so nothing an existing consumer imports moves.
+
+Clause-②: yes (widening)

From d3895054b2f5e04e46351840c18d0bc5c0dddb1d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 14:53:46 +0000
Subject: [PATCH 04/11] chore(spec): regenerate the three os-regen artifacts
 from the merged tree

Discharges the merge deferral from 5f0fef7a24. Both sides survive: this
branch's nine `Hook*` entries on `./data` and main's `driverSupportsTransactions`.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 packages/spec/api-surface-declarations/data.txt | 17 +++++++++++++++--
 packages/spec/api-surface/data.json             |  1 +
 packages/spec/export-origins/data.json          |  1 +
 3 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/packages/spec/api-surface-declarations/data.txt b/packages/spec/api-surface-declarations/data.txt
index 50367239f8f..39a459a28a6 100644
--- a/packages/spec/api-surface-declarations/data.txt
+++ b/packages/spec/api-surface-declarations/data.txt
@@ -12,8 +12,8 @@
 # excluded: documentation drift is `check:docs`'s axis, not this one.
 #
 # entry: ./data
-# exported names: 841
-# declarations: 854
+# exported names: 842
+# declarations: 855
 #
 # GENERATED — ⛔ never hand-edited. Regenerate after a real build:
 #   pnpm --filter @objectstack/spec build && pnpm --filter @objectstack/spec gen:api-surface-declarations
@@ -5288,6 +5288,7 @@ declare const DriverCapabilitiesSchema: z.ZodObject<{
     }>, z.ZodBoolean>>;
     autonumber: z.ZodOptional<z.ZodBoolean>;
     batchSchemaSync: z.ZodOptional<z.ZodBoolean>;
+    transactionsUnsupported: z.ZodOptional<z.ZodBoolean>;
     create: z.ZodOptional<z.ZodNever>;
     read: z.ZodOptional<z.ZodNever>;
     update: z.ZodOptional<z.ZodNever>;
@@ -5355,6 +5356,7 @@ declare const DriverConfigSchema: z.ZodObject<{
         }>, z.ZodBoolean>>;
         autonumber: z.ZodOptional<z.ZodBoolean>;
         batchSchemaSync: z.ZodOptional<z.ZodBoolean>;
+        transactionsUnsupported: z.ZodOptional<z.ZodBoolean>;
         create: z.ZodOptional<z.ZodNever>;
         read: z.ZodOptional<z.ZodNever>;
         update: z.ZodOptional<z.ZodNever>;
@@ -5428,6 +5430,7 @@ declare const DriverInterfaceSchema: z.ZodObject<{
         }>, z.ZodBoolean>>;
         autonumber: z.ZodOptional<z.ZodBoolean>;
         batchSchemaSync: z.ZodOptional<z.ZodBoolean>;
+        transactionsUnsupported: z.ZodOptional<z.ZodBoolean>;
         create: z.ZodOptional<z.ZodNever>;
         read: z.ZodOptional<z.ZodNever>;
         update: z.ZodOptional<z.ZodNever>;
@@ -15216,6 +15219,7 @@ declare const NoSQLDriverConfigSchema: z.ZodObject<{
         }>, z.ZodBoolean>>;
         autonumber: z.ZodOptional<z.ZodBoolean>;
         batchSchemaSync: z.ZodOptional<z.ZodBoolean>;
+        transactionsUnsupported: z.ZodOptional<z.ZodBoolean>;
         create: z.ZodOptional<z.ZodNever>;
         read: z.ZodOptional<z.ZodNever>;
         update: z.ZodOptional<z.ZodNever>;
@@ -21653,6 +21657,7 @@ declare const SQLDriverConfigSchema: z.ZodObject<{
         }>, z.ZodBoolean>>;
         autonumber: z.ZodOptional<z.ZodBoolean>;
         batchSchemaSync: z.ZodOptional<z.ZodBoolean>;
+        transactionsUnsupported: z.ZodOptional<z.ZodBoolean>;
         create: z.ZodOptional<z.ZodNever>;
         read: z.ZodOptional<z.ZodNever>;
         update: z.ZodOptional<z.ZodNever>;
@@ -22963,6 +22968,14 @@ declare function driverConfigJsonSchema(schema: z.ZodType): () => Record<string,
 // ── driverHasLocalDefault (function) ──
 declare function driverHasLocalDefault(driver: unknown): boolean;
 
+// ── driverSupportsTransactions (function) ──
+declare function driverSupportsTransactions(driver: {
+    beginTransaction?: unknown;
+    supports?: {
+        transactionsUnsupported?: boolean | undefined;
+    } | undefined;
+} | null | undefined): boolean;
+
 // ── effectiveOperationsArray (function) ──
 declare function effectiveOperationsArray(eff: EffectiveApiMethods): ApiOperation[];
 
diff --git a/packages/spec/api-surface/data.json b/packages/spec/api-surface/data.json
index b2de72b8713..358029cdb6e 100644
--- a/packages/spec/api-surface/data.json
+++ b/packages/spec/api-surface/data.json
@@ -741,6 +741,7 @@
     "discriminateDefaultValueShape (function)",
     "driverConfigJsonSchema (function)",
     "driverHasLocalDefault (function)",
+    "driverSupportsTransactions (function)",
     "effectiveOperationsArray (function)",
     "emptyGroupValueFor (function)",
     "fieldForm (const)",
diff --git a/packages/spec/export-origins/data.json b/packages/spec/export-origins/data.json
index 870c4c6c344..7b7a132bd9f 100644
--- a/packages/spec/export-origins/data.json
+++ b/packages/spec/export-origins/data.json
@@ -728,6 +728,7 @@
     "discriminateDefaultValueShape": "src/data/default-value-shape.ts#discriminateDefaultValueShape (function)",
     "driverConfigJsonSchema": "src/data/driver/common.zod.ts#driverConfigJsonSchema (function)",
     "driverHasLocalDefault": "src/data/driver/config-registry.zod.ts#driverHasLocalDefault (function)",
+    "driverSupportsTransactions": "src/data/driver.zod.ts#driverSupportsTransactions (function)",
     "effectiveOperationsArray": "src/data/api-derivation.ts#effectiveOperationsArray (function)",
     "emptyGroupValueFor": "src/data/aggregation-policy.ts#emptyGroupValueFor (function)",
     "fieldForm": "src/data/field.form.ts#fieldForm (const)",

From 0532daed4e1c8d8cb8b41b2baa13e0e19949dc35 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 15:48:09 +0000
Subject: [PATCH 05/11] fix(spec): make the hook face's structurally-referenced
 types nameable from ./data

Contract review's one blocking finding. `HookApi.transaction` references
`EngineTransactionInfo` and `EngineTransactionOptions` structurally, and
`HookContext.api` has referenced `IScopedContext` the same way since #5945;
none was reachable from `./data`, so a consumer importing only that entry and
emitting declarations answered TS2883. Three type-only re-exports, zero
runtime.

`check:entry-nameability` cannot see this: it probes the call surface of value
exports, and `HookApi` is a type. The sibling test now imports the three names
THROUGH `./hook-api`, so deleting a re-export reds `check:test-typecheck`.

Also records two decisions the review settled, in the docblock rather than as
open questions: `top` stays omitted (it is absent from
`ENGINE_FIND_OPTION_KEYS` itself, so the face carries the engine's accepted set
verbatim), and `HookDoc` stays a string-keyed record of unknown (loud refusal,
one-word call-site remedy, and widening later is the additive direction).

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/18163-export-hook-api-types.md |  4 +-
 packages/spec/src/data/hook-api.test.ts   | 37 +++++++++-
 packages/spec/src/data/hook-api.ts        | 82 +++++++++++++++++++++--
 3 files changed, 115 insertions(+), 8 deletions(-)

diff --git a/.changeset/18163-export-hook-api-types.md b/.changeset/18163-export-hook-api-types.md
index 0688ad57bac..4a55e23472a 100644
--- a/.changeset/18163-export-hook-api-types.md
+++ b/.changeset/18163-export-hook-api-types.md
@@ -2,7 +2,7 @@
 '@objectstack/spec': minor
 ---
 
-`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163).
+`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo`, `EngineTransactionOptions` and `IScopedContext`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
 
 ```ts
 import type { HookApi } from '@objectstack/spec/data';
@@ -19,6 +19,6 @@ The platform already implemented this surface; it just never published a type an
 - **Every option shape is DERIVED, not transcribed.** Each is an `Omit`/`Pick` over the `Engine*Options` schemas that the engine's own per-method legal-key sets are pinned against, so a key added to a schema reaches the published type in the same run it reaches the engine's accepted set. `count` is the one shape without the driver pass-through keys, because the engine forwards no bag on that method and rejects them there — engine behaviour no document states, and exactly what a hand-written copy gets wrong.
 - **What is deliberately absent, each for a stated reason**: `context` (the repository injects it and discards a caller's), the `cursor` / `distinct` / `upsert` tombstones, `sudo()` (the #5945 exclusion stands — `Hook.runAs: 'system'` is the declared way to run elevated), and `aggregate` / `execute` / `create` / `deleteById`.
 
-Additive only: nine new exported names from `./data`, no removal and no signature change, so nothing an existing consumer imports moves.
+Additive only: twelve new exported names from `./data` (nine new declarations plus three type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
 
 Clause-②: yes (widening)
diff --git a/packages/spec/src/data/hook-api.test.ts b/packages/spec/src/data/hook-api.test.ts
index f5c77db697c..c5b505eb283 100644
--- a/packages/spec/src/data/hook-api.test.ts
+++ b/packages/spec/src/data/hook-api.test.ts
@@ -12,12 +12,21 @@
  *     against. If `HookApi` ever declares a member or a return the checked
  *     contract cannot satisfy, this file stops compiling.
  *
- *     ⚠️ NOT MEASURED HERE, by construction: that the CLASS `ScopedContext`
+ *     ⚠️ NOT PINNED HERE, by construction: that the CLASS `ScopedContext`
  *     satisfies `HookApi`. `packages/spec` must not depend on
  *     `packages/objectql` (only objectql can execute a dispatch, and spec is
  *     the contract both sides read), so the class-vs-type leg belongs in
  *     objectql beside `hook-input-shape-contract.test.ts`, which is where the
- *     engine's other spec-contract pins live.
+ *     engine's other spec-contract pins live. It has been MEASURED once — this
+ *     card's contract review ran an objectql scratch probe with negative
+ *     controls and both `ScopedContext extends HookApi` and
+ *     `ObjectRepository extends HookObjectApi` hold — but a measurement taken
+ *     once is not a pin, and the standing pin is still owed.
+ *
+ *     ⛔ The assignability leg below is NOT a substitute for it: it runs the
+ *     other direction. `IScopedObjectRepository` declares no `delete`, so
+ *     "`HookApi` is a usable `IScopedContext`" cannot stand in for "the object
+ *     the engine builds is a usable `HookApi`".
  *
  *  2. **The option bags drift from the engine's accepted vocabulary.** Every
  *     shape is derived by `Omit`/`Pick` from the `Engine*Options` schemas the
@@ -42,12 +51,15 @@ import {
   EngineUpdateOptionsSchema,
 } from './data-engine.zod';
 import type {
+  EngineTransactionInfo,
+  EngineTransactionOptions,
   HookApi,
   HookCountQuery,
   HookDeleteOptions,
   HookObjectApi,
   HookQuery,
   HookUpdateOptions,
+  IScopedContext as ReExportedScopedContext,
 } from './hook-api';
 import type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';
 
@@ -170,6 +182,27 @@ describe('HookApi — the published hook ctx.api face', () => {
     });
   });
 
+  describe('nameability — every type this face references structurally is reachable here', () => {
+    // These three names are imported FROM './hook-api', not from the contracts
+    // files that declare them, so deleting a re-export line does not merely
+    // widen the surface: it stops this file compiling and `check:test-typecheck`
+    // goes red. That is the whole pin — a consumer importing only
+    // `@objectstack/spec/data` and emitting declarations answers TS2883 without
+    // them, and `check:entry-nameability` cannot see it (it probes the call
+    // surface of VALUE exports; `HookApi` is a type).
+    it('the transaction signature\'s two types, and the type ctx.api already carries', () => {
+      const infoIsReachable: Assignable<EngineTransactionInfo, EngineTransactionInfo> = true;
+      const optsIsReachable: Assignable<EngineTransactionOptions, EngineTransactionOptions> = true;
+      // Same declaration, reached through both entries — one declaration, two
+      // paths, which is what `check:dual-source-exports` asks about.
+      const oneDeclaration: Assignable<ReExportedScopedContext, IScopedContext> = true;
+      const andBack: Assignable<IScopedContext, ReExportedScopedContext> = true;
+      expect([infoIsReachable, optsIsReachable, oneDeclaration, andBack]).toEqual([
+        true, true, true, true,
+      ]);
+    });
+  });
+
   describe('drift pin — each derived shape equals KEPT ∪ OMITTED on its schema', () => {
     // Restated here on purpose rather than imported: a schema key added later
     // has to be DECIDED onto one of the two lists, and this pin is what forces
diff --git a/packages/spec/src/data/hook-api.ts b/packages/spec/src/data/hook-api.ts
index c3165c0ed22..7f67c6432aa 100644
--- a/packages/spec/src/data/hook-api.ts
+++ b/packages/spec/src/data/hook-api.ts
@@ -55,9 +55,18 @@
  * ruling's explicit instruction for `filter`, and the SAME measurement carries
  * `top`: both are alias spellings of a canonical key, both throw on a value
  * disagreement, neither adds any expressive power. Authors spell `where` and
- * `limit`. ⚠️ REVIEW POINT — the ruling names `filter`; extending it to `top`
- * is this file's reading of the same rule, and is the one place a reviewer
- * should decide whether the type should be wider than the ruling's letter.
+ * `limit`.
+ *
+ * DECIDED at contract review, not left open: `top` stays omitted. The ruling
+ * names `filter` only, so the question was whether this type may be narrower
+ * than the ruling's letter — and the measurement says it is not narrower at
+ * all. `ENGINE_FIND_OPTION_KEYS` itself has no `top`: the alias is folded and
+ * DELETED before the legal-key check runs, which is why objectql's own drift
+ * pin skips it. So `HookQuery` carries the engine's accepted set verbatim, and
+ * re-adding `top` would put the published face out of step with the engine
+ * while re-opening for `{ limit, top }` exactly the coin toss the ruling closed
+ * for `{ where, filter }`. It is also the reversible direction: adding a key
+ * later is additive, removing one is breaking.
  *
  * ## What else is deliberately off the bags, each with its reason
  *
@@ -144,7 +153,27 @@ export type HookQuery = Omit<EngineQueryOptions, 'context' | 'top' | 'cursor' |
  */
 export type HookCountQuery = Omit<EngineCountOptions, 'context'>;
 
-/** A record payload a hook write carries. */
+/**
+ * A record payload a hook write carries.
+ *
+ * DECIDED at contract review: this stays `Record` of `string` to `unknown`,
+ * and is NOT widened to the `any`-valued or `object`-valued form.
+ *
+ * What the narrow form costs, measured: a payload whose type is an INTERFACE is
+ * refused — `TS2345: Index signature for type 'string' is missing in type 'X'`
+ * — because TypeScript grants an implicit index signature to a type alias and
+ * not to an interface. The engine and `IScopedObjectRepository` both accept it,
+ * so this is the one shape in this file that sits narrower than the seam.
+ *
+ * Kept anyway, for three reasons. It fails LOUDLY and at the authoring site,
+ * never silently at the driver. The remedy is one word at the call site —
+ * declare the payload as a `type` rather than an `interface`, or spread it
+ * (`insert({ ...record })`, which is what a hook writing from `ctx.input`
+ * already does, and which compiles today). And it is the REVERSIBLE direction:
+ * widening later is additive, while narrowing later would break every consumer
+ * that had annotated a value as `HookDoc` and indexed it — the same structural
+ * argument that settled `top` above.
+ */
 export type HookDoc = Record<string, unknown>;
 
 /**
@@ -276,3 +305,48 @@ export interface HookApi {
     opts?: EngineTransactionOptions,
   ): Promise<T>;
 }
+
+/**
+ * [BLOCKING finding of this card's contract review] The types this entry's own
+ * public declarations reference STRUCTURALLY, re-exported so they are nameable
+ * from the entry that publishes them.
+ *
+ * The governing text is the maintainer ruling of 2026-08-23 on #11350, recorded
+ * in `packages/spec/scripts/check-entry-nameability.ts` and chartered
+ * 2026-08-25 on #11709: a type that appears structurally in an entry's public
+ * declarations must be nameable from that same entry.
+ *
+ * Measured in the consumer shape this card exists to serve — a program that
+ * imports ONLY `@objectstack/spec/data` and emits declarations:
+ *
+ * ```
+ * export const inTx = (api: HookApi) =>
+ *   api.transaction(async (tx, info) => ({ tx, info }));
+ *
+ * error TS2883: The inferred type of 'inTx' cannot be named without a
+ * reference to 'EngineTransactionInfo'. This is likely not portable.
+ * ```
+ *
+ * The second position — `transaction`'s `opts` — answers the same way for
+ * `EngineTransactionOptions`, and `HookContext.api` has answered it for
+ * `IScopedContext` since #5945, which is why that third name is here too: it is
+ * the SAME defect in the SAME entry, its remedy is this same one-line form, it
+ * lands in this file rather than in any file another card holds, and it adds no
+ * gate beyond the three this diff already regenerates. Leaving it would publish
+ * a hook seam that still cannot be written from one entry — the exact gap this
+ * card was opened to close.
+ *
+ * ⛔ `check:entry-nameability` is NOT the instrument that answers this. By its
+ * own docblock it probes the CALL surface of VALUE exports that have a call
+ * signature; `HookApi` is a type, so no probe of that gate ever reaches
+ * `api.transaction(...)`. It runs green here and is blind to this by
+ * construction — the reachable radius is value exports, and these three names
+ * are a known target outside it. The instrument that answers is a consumer
+ * program with `declaration` emit, which is what the excerpt above is.
+ *
+ * Type-only re-exports: they add three names to this entry and no runtime byte,
+ * and each is ONE declaration reachable from two entries rather than two
+ * declarations sharing a name, which is what `check:dual-source-exports` asks.
+ */
+export type { EngineTransactionInfo, EngineTransactionOptions } from '../contracts/objectql-engine';
+export type { IScopedContext } from '../contracts/scoped-context';

From db6a3dfd0327444980f8608c15a3b95a82f6de10 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 15:51:53 +0000
Subject: [PATCH 06/11] chore(spec): regenerate the three artifacts for the
 nameability re-exports

Exported names 842 -> 845, declarations 855 -> 858. Added exactly
EngineTransactionInfo, EngineTransactionOptions and IScopedContext on ./data;
no removals.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../spec/api-surface-declarations/data.txt    | 77 ++++++++++++++++++-
 packages/spec/api-surface/data.json           |  3 +
 packages/spec/export-origins/data.json        |  3 +
 3 files changed, 81 insertions(+), 2 deletions(-)

diff --git a/packages/spec/api-surface-declarations/data.txt b/packages/spec/api-surface-declarations/data.txt
index 39a459a28a6..0bf5a6b2d7b 100644
--- a/packages/spec/api-surface-declarations/data.txt
+++ b/packages/spec/api-surface-declarations/data.txt
@@ -12,8 +12,8 @@
 # excluded: documentation drift is `check:docs`'s axis, not this one.
 #
 # entry: ./data
-# exported names: 842
-# declarations: 855
+# exported names: 845
+# declarations: 858
 #
 # GENERATED — ⛔ never hand-edited. Regenerate after a real build:
 #   pnpm --filter @objectstack/spec build && pnpm --filter @objectstack/spec gen:api-surface-declarations
@@ -6179,6 +6179,46 @@ declare const EngineQueryOptionsSchema: z.ZodObject<{
     distinct: z.ZodOptional<z.ZodNever>;
 }, z.core.$strip>;
 
+// ── EngineTransactionInfo (interface) ──
+interface EngineTransactionInfo {
+    /**
+     * `true` when THIS call opened the transaction and therefore owns its
+     * commit/rollback; `false` when it JOINED an already-open ambient one
+     * (ADR-0067 D2) and some outer caller owns the outcome.
+     *
+     * The join is correct and stays — a nested `begin` would take a second
+     * connection (deadlocking a single-connection SQLite pool) and would not be
+     * covered by the outer rollback. What was missing is that the callback
+     * could not TELL: a joined callback's `throw` unwinds work the outer owner
+     * may still commit or roll back on its own terms, and guarantees phrased
+     * as "this whole unit rolls back together" (`batchData`'s rollback
+     * response, ADR-0119 D4) hold only for the owner. A callback that must not
+     * promise what it does not control reads `owned` and says so.
+     */
+    owned: boolean;
+}
+
+// ── EngineTransactionOptions (interface) ──
+interface EngineTransactionOptions {
+    /**
+     * Fail CLOSED when the datasource cannot give a real transaction.
+     *
+     * Default (`undefined` / `false`) keeps ADR-0119 D1's declared degrade: a
+     * driver without `beginTransaction` runs the callback with no transaction
+     * and no rollback, warning once. That degrade is right for callers who can
+     * live without atomicity (test doubles, in-memory drivers) and wrong for
+     * callers whose whole reason to open a transaction is the rollback.
+     *
+     * With `require: true` the engine THROWS instead of degrading, before the
+     * callback runs — so a caller that cannot tolerate losing atomicity states
+     * it once, at the call site, instead of re-deriving `batchData`'s probe.
+     * That probe is the precedent being generalized here (ADR-0119 D4, cited in
+     * older text as ADR-0118 D4 — see that ADR's renumbering note): an `atomic`
+     * request refuses rather than silently running best-effort.
+     */
+    require?: boolean;
+}
+
 // ── EngineUpdateOptions (type) ──
 type EngineUpdateOptions = z.input<typeof EngineUpdateOptionsSchema>;
 
@@ -14591,6 +14631,39 @@ declare const INLINE_CREDENTIAL_REFUSED: (key: string) => string;
 // ── INSTANT_TYPES (const) ──
 declare const INSTANT_TYPES: ReadonlySet<string>;
 
+// ── IScopedContext (interface) ──
+interface IScopedContext {
+    /** The repository for `name`, bound to this context. */
+    object(name: string): IScopedObjectRepository;
+    /**
+     * Run `callback` inside one driver transaction: committed when it returns,
+     * rolled back when it throws.
+     *
+     * The callback receives a NEW `IScopedContext` whose operations share the
+     * transaction handle — reach objects through THAT context (`tx.object(…)`),
+     * not the outer one, or the writes land outside the transaction.
+     *
+     * ## Why the callback's second parameter is declared even though no corpus
+     * site reads it
+     *
+     * The evidence bar above governs WHICH MEMBERS exist, not what a declared
+     * member's signature is allowed to say. A parameter list describes what the
+     * PRODUCER hands the callback, and the producer hands it two arguments
+     * unconditionally (`ScopedContext.transaction`, #5696): declaring one would
+     * be a false statement that additionally makes `async (tx, info) => …`
+     * — legal, working code — a compile error. Contravariance means the
+     * zero-argument and one-argument callbacks the corpus actually writes still
+     * satisfy this, so the truthful signature is also the more permissive one.
+     * {@link EngineTransactionInfo} is reused rather than re-spelled, for the
+     * same reason `opts` is: ADR-0119 D1 and #5696 rule that this surface is a
+     * second IMPLEMENTATION of `IObjectQLEngine.transaction`, never a second
+     * DIALECT of it — `opts.require`'s fail-closed refusal is honoured here
+     * identically, and a contract that omitted it would re-open in declaration
+     * the dialect the implementation was made to close.
+     */
+    transaction<T>(callback: (trxCtx: IScopedContext, info: EngineTransactionInfo) => Promise<T>, opts?: EngineTransactionOptions): Promise<T>;
+}
+
 // ── ImportFieldMapping (type) ──
 type ImportFieldMapping = z.input<typeof ImportFieldMappingSchema>;
 
diff --git a/packages/spec/api-surface/data.json b/packages/spec/api-surface/data.json
index 358029cdb6e..ce4c20e4182 100644
--- a/packages/spec/api-surface/data.json
+++ b/packages/spec/api-surface/data.json
@@ -238,6 +238,8 @@
     "EngineQueryOptions (type)",
     "EngineQueryOptionsParsed (type)",
     "EngineQueryOptionsSchema (const)",
+    "EngineTransactionInfo (interface)",
+    "EngineTransactionOptions (interface)",
     "EngineUpdateOptions (type)",
     "EngineUpdateOptionsSchema (const)",
     "EqualityOperatorSchema (const)",
@@ -363,6 +365,7 @@
     "IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES (const)",
+    "IScopedContext (interface)",
     "ImportFieldMapping (type)",
     "ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema (const)",
diff --git a/packages/spec/export-origins/data.json b/packages/spec/export-origins/data.json
index 7b7a132bd9f..023cde93767 100644
--- a/packages/spec/export-origins/data.json
+++ b/packages/spec/export-origins/data.json
@@ -233,6 +233,8 @@
     "EngineQueryOptions": "src/data/data-engine.zod.ts#EngineQueryOptions (type)",
     "EngineQueryOptionsParsed": "src/data/data-engine.zod.ts#EngineQueryOptionsParsed (type)",
     "EngineQueryOptionsSchema": "src/data/data-engine.zod.ts#EngineQueryOptionsSchema (const)",
+    "EngineTransactionInfo": "src/contracts/objectql-engine.ts#EngineTransactionInfo (interface)",
+    "EngineTransactionOptions": "src/contracts/objectql-engine.ts#EngineTransactionOptions (interface)",
     "EngineUpdateOptions": "src/data/data-engine.zod.ts#EngineUpdateOptions (type)",
     "EngineUpdateOptionsSchema": "src/data/data-engine.zod.ts#EngineUpdateOptionsSchema (const)",
     "EqualityOperatorSchema": "src/data/filter.zod.ts#EqualityOperatorSchema (const)",
@@ -353,6 +355,7 @@
     "IMPORT_REFERENCE_TYPES": "src/data/import-coercion.ts#IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED": "src/data/driver/common.zod.ts#INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES": "src/data/field-value.zod.ts#INSTANT_TYPES (const)",
+    "IScopedContext": "src/contracts/scoped-context.ts#IScopedContext (interface)",
     "ImportFieldMapping": "src/data/mapping.zod.ts#ImportFieldMapping (type)",
     "ImportFieldMappingParsed": "src/data/mapping.zod.ts#ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema": "src/data/mapping.zod.ts#ImportFieldMappingSchema (const)",

From 2abf0a3a9d5e78c4f0ce77fc98340aaa008fbca7 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 15:56:56 +0000
Subject: [PATCH 07/11] =?UTF-8?q?fix(spec):=20close=20the=20ctx.api=20name?=
 =?UTF-8?q?ability=20chain=20completely=20=E2=80=94=20four=20names,=20not?=
 =?UTF-8?q?=20three?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Measured, not reasoned: exporting `IScopedContext` alone is a HALF closure,
because `IScopedContext.object(name)` returns `IScopedObjectRepository` and a
consumer writing `ctx.api.object('deal')` still answered TS2883 on that fourth
name. With all four, a probe covering both `transaction` arguments, `ctx.api`,
`ctx.api.object(...)`, `api.object(...)` and a repository read emits at exit 0
and every inferred type in the emitted declarations resolves through
`@objectstack/spec/data`. The chain terminates there — the repository's members
answer in structural types that name nothing further.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/18163-export-hook-api-types.md |  4 ++--
 packages/spec/src/data/hook-api.test.ts   | 11 ++++++---
 packages/spec/src/data/hook-api.ts        | 29 ++++++++++++++++-------
 3 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/.changeset/18163-export-hook-api-types.md b/.changeset/18163-export-hook-api-types.md
index 4a55e23472a..fa69db7cd90 100644
--- a/.changeset/18163-export-hook-api-types.md
+++ b/.changeset/18163-export-hook-api-types.md
@@ -2,7 +2,7 @@
 '@objectstack/spec': minor
 ---
 
-`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo`, `EngineTransactionOptions` and `IScopedContext`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
+`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo`, `EngineTransactionOptions`, `IScopedContext` and `IScopedObjectRepository`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
 
 ```ts
 import type { HookApi } from '@objectstack/spec/data';
@@ -19,6 +19,6 @@ The platform already implemented this surface; it just never published a type an
 - **Every option shape is DERIVED, not transcribed.** Each is an `Omit`/`Pick` over the `Engine*Options` schemas that the engine's own per-method legal-key sets are pinned against, so a key added to a schema reaches the published type in the same run it reaches the engine's accepted set. `count` is the one shape without the driver pass-through keys, because the engine forwards no bag on that method and rejects them there — engine behaviour no document states, and exactly what a hand-written copy gets wrong.
 - **What is deliberately absent, each for a stated reason**: `context` (the repository injects it and discards a caller's), the `cursor` / `distinct` / `upsert` tombstones, `sudo()` (the #5945 exclusion stands — `Hook.runAs: 'system'` is the declared way to run elevated), and `aggregate` / `execute` / `create` / `deleteById`.
 
-Additive only: twelve new exported names from `./data` (nine new declarations plus three type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
+Additive only: thirteen new exported names from `./data` (nine new declarations plus four type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
 
 Clause-②: yes (widening)
diff --git a/packages/spec/src/data/hook-api.test.ts b/packages/spec/src/data/hook-api.test.ts
index c5b505eb283..955a9bbf076 100644
--- a/packages/spec/src/data/hook-api.test.ts
+++ b/packages/spec/src/data/hook-api.test.ts
@@ -60,6 +60,7 @@ import type {
   HookQuery,
   HookUpdateOptions,
   IScopedContext as ReExportedScopedContext,
+  IScopedObjectRepository as ReExportedScopedRepository,
 } from './hook-api';
 import type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';
 
@@ -190,15 +191,19 @@ describe('HookApi — the published hook ctx.api face', () => {
     // `@objectstack/spec/data` and emitting declarations answers TS2883 without
     // them, and `check:entry-nameability` cannot see it (it probes the call
     // surface of VALUE exports; `HookApi` is a type).
-    it('the transaction signature\'s two types, and the type ctx.api already carries', () => {
+    it('the transaction signature\'s two types, and the ctx.api pair', () => {
       const infoIsReachable: Assignable<EngineTransactionInfo, EngineTransactionInfo> = true;
       const optsIsReachable: Assignable<EngineTransactionOptions, EngineTransactionOptions> = true;
       // Same declaration, reached through both entries — one declaration, two
       // paths, which is what `check:dual-source-exports` asks about.
       const oneDeclaration: Assignable<ReExportedScopedContext, IScopedContext> = true;
       const andBack: Assignable<IScopedContext, ReExportedScopedContext> = true;
-      expect([infoIsReachable, optsIsReachable, oneDeclaration, andBack]).toEqual([
-        true, true, true, true,
+      // The repository comes with it: `IScopedContext.object(name)` returns it,
+      // so exporting the context without it is a HALF closure — measured as a
+      // surviving TS2883 on `ctx.api.object(...)`.
+      const repoReachable: Assignable<ReExportedScopedRepository, IScopedObjectRepository> = true;
+      expect([infoIsReachable, optsIsReachable, oneDeclaration, andBack, repoReachable]).toEqual([
+        true, true, true, true, true,
       ]);
     });
   });
diff --git a/packages/spec/src/data/hook-api.ts b/packages/spec/src/data/hook-api.ts
index 7f67c6432aa..281b6c98750 100644
--- a/packages/spec/src/data/hook-api.ts
+++ b/packages/spec/src/data/hook-api.ts
@@ -328,13 +328,24 @@ export interface HookApi {
  * ```
  *
  * The second position — `transaction`'s `opts` — answers the same way for
- * `EngineTransactionOptions`, and `HookContext.api` has answered it for
- * `IScopedContext` since #5945, which is why that third name is here too: it is
- * the SAME defect in the SAME entry, its remedy is this same one-line form, it
- * lands in this file rather than in any file another card holds, and it adds no
- * gate beyond the three this diff already regenerates. Leaving it would publish
- * a hook seam that still cannot be written from one entry — the exact gap this
- * card was opened to close.
+ * `EngineTransactionOptions`. Those two are the blocking finding.
+ *
+ * The other two names close the SAME defect one frame out, and they come as a
+ * PAIR because that is what the measurement said. `HookContext.api` has leaked
+ * `IScopedContext` since #5945, and exporting that name alone is a HALF
+ * closure: `IScopedContext.object(name)` returns `IScopedObjectRepository`, so
+ * with three names `(ctx) => ctx.api!.object('deal')` still answered TS2883 on
+ * that fourth name. With all four, a probe carrying every position — both
+ * `transaction` arguments, `ctx.api`, `ctx.api.object(…)`, `api.object(…)` and
+ * a repository read — emits at exit 0, and the emitted declarations resolve
+ * every inferred type through `@objectstack/spec/data`. The chain terminates
+ * there: the repository's own members answer in structural types
+ * (`Promise` of `Record` of `string` to `any`, or `null`) that name nothing
+ * further. Taken in one stroke because leaving it publishes a hook seam whose
+ * own `ctx.api` cannot be named from the entry that publishes the seam — the
+ * exact gap this card was opened to close — and because all four are one-line
+ * re-exports in this file, of declarations `@objectstack/spec/contracts`
+ * already publishes, adding no gate beyond the three this diff regenerates.
  *
  * ⛔ `check:entry-nameability` is NOT the instrument that answers this. By its
  * own docblock it probes the CALL surface of VALUE exports that have a call
@@ -344,9 +355,9 @@ export interface HookApi {
  * are a known target outside it. The instrument that answers is a consumer
  * program with `declaration` emit, which is what the excerpt above is.
  *
- * Type-only re-exports: they add three names to this entry and no runtime byte,
+ * Type-only re-exports: they add four names to this entry and no runtime byte,
  * and each is ONE declaration reachable from two entries rather than two
  * declarations sharing a name, which is what `check:dual-source-exports` asks.
  */
 export type { EngineTransactionInfo, EngineTransactionOptions } from '../contracts/objectql-engine';
-export type { IScopedContext } from '../contracts/scoped-context';
+export type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';

From 3d2de76608758158ec9d50a6d3e8a91677b3f7ff Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 16:10:22 +0000
Subject: [PATCH 08/11] fix(spec): take the two names the finding owes, and
 decline the third on measurement
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reverts the exploratory fourth name. The blocking finding is
`EngineTransactionInfo` and `EngineTransactionOptions`, both introduced to this
entry by this card's own declarations; those two ship.

The optional leg — `IScopedContext`, leaking off `HookContext.api` since #5945
— is declined here, measured rather than waved off. It needs TWO names, not
one: `IScopedContext.object(name)` returns `IScopedObjectRepository`, so with
the context exported alone `ctx.api.object('deal')` still answered TS2883 on
the repository. And the second name is not free: adding it reorders members
inside object type literals in the unrelated `ui` shard, 330 lines that
`check:api-surface-declarations` reports as "33 reshaped" and asks a reviewer
to rule on. Measured order-only — identical token multiset, identical line
count, generator stable against a fixed dist — but an adjudication in a shard
this card does not touch is its own card, not a rider on a FAIL remediation.

Surface delta vs the merge base: exported names 833 -> 844, no removals, and
`ui.txt` untouched.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .changeset/18163-export-hook-api-types.md     |  4 +-
 .../spec/api-surface-declarations/data.txt    | 37 +-------------
 packages/spec/api-surface/data.json           |  1 -
 packages/spec/export-origins/data.json        |  1 -
 packages/spec/src/data/hook-api.test.ts       | 16 +-----
 packages/spec/src/data/hook-api.ts            | 51 +++++++++++--------
 6 files changed, 37 insertions(+), 73 deletions(-)

diff --git a/.changeset/18163-export-hook-api-types.md b/.changeset/18163-export-hook-api-types.md
index fa69db7cd90..8fd064cd754 100644
--- a/.changeset/18163-export-hook-api-types.md
+++ b/.changeset/18163-export-hook-api-types.md
@@ -2,7 +2,7 @@
 '@objectstack/spec': minor
 ---
 
-`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo`, `EngineTransactionOptions`, `IScopedContext` and `IScopedObjectRepository`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
+`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo` and `EngineTransactionOptions`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
 
 ```ts
 import type { HookApi } from '@objectstack/spec/data';
@@ -19,6 +19,6 @@ The platform already implemented this surface; it just never published a type an
 - **Every option shape is DERIVED, not transcribed.** Each is an `Omit`/`Pick` over the `Engine*Options` schemas that the engine's own per-method legal-key sets are pinned against, so a key added to a schema reaches the published type in the same run it reaches the engine's accepted set. `count` is the one shape without the driver pass-through keys, because the engine forwards no bag on that method and rejects them there — engine behaviour no document states, and exactly what a hand-written copy gets wrong.
 - **What is deliberately absent, each for a stated reason**: `context` (the repository injects it and discards a caller's), the `cursor` / `distinct` / `upsert` tombstones, `sudo()` (the #5945 exclusion stands — `Hook.runAs: 'system'` is the declared way to run elevated), and `aggregate` / `execute` / `create` / `deleteById`.
 
-Additive only: thirteen new exported names from `./data` (nine new declarations plus four type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
+Additive only: eleven new exported names from `./data` (nine new declarations plus two type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
 
 Clause-②: yes (widening)
diff --git a/packages/spec/api-surface-declarations/data.txt b/packages/spec/api-surface-declarations/data.txt
index 0bf5a6b2d7b..d3e7d364cf5 100644
--- a/packages/spec/api-surface-declarations/data.txt
+++ b/packages/spec/api-surface-declarations/data.txt
@@ -12,8 +12,8 @@
 # excluded: documentation drift is `check:docs`'s axis, not this one.
 #
 # entry: ./data
-# exported names: 845
-# declarations: 858
+# exported names: 844
+# declarations: 857
 #
 # GENERATED — ⛔ never hand-edited. Regenerate after a real build:
 #   pnpm --filter @objectstack/spec build && pnpm --filter @objectstack/spec gen:api-surface-declarations
@@ -14631,39 +14631,6 @@ declare const INLINE_CREDENTIAL_REFUSED: (key: string) => string;
 // ── INSTANT_TYPES (const) ──
 declare const INSTANT_TYPES: ReadonlySet<string>;
 
-// ── IScopedContext (interface) ──
-interface IScopedContext {
-    /** The repository for `name`, bound to this context. */
-    object(name: string): IScopedObjectRepository;
-    /**
-     * Run `callback` inside one driver transaction: committed when it returns,
-     * rolled back when it throws.
-     *
-     * The callback receives a NEW `IScopedContext` whose operations share the
-     * transaction handle — reach objects through THAT context (`tx.object(…)`),
-     * not the outer one, or the writes land outside the transaction.
-     *
-     * ## Why the callback's second parameter is declared even though no corpus
-     * site reads it
-     *
-     * The evidence bar above governs WHICH MEMBERS exist, not what a declared
-     * member's signature is allowed to say. A parameter list describes what the
-     * PRODUCER hands the callback, and the producer hands it two arguments
-     * unconditionally (`ScopedContext.transaction`, #5696): declaring one would
-     * be a false statement that additionally makes `async (tx, info) => …`
-     * — legal, working code — a compile error. Contravariance means the
-     * zero-argument and one-argument callbacks the corpus actually writes still
-     * satisfy this, so the truthful signature is also the more permissive one.
-     * {@link EngineTransactionInfo} is reused rather than re-spelled, for the
-     * same reason `opts` is: ADR-0119 D1 and #5696 rule that this surface is a
-     * second IMPLEMENTATION of `IObjectQLEngine.transaction`, never a second
-     * DIALECT of it — `opts.require`'s fail-closed refusal is honoured here
-     * identically, and a contract that omitted it would re-open in declaration
-     * the dialect the implementation was made to close.
-     */
-    transaction<T>(callback: (trxCtx: IScopedContext, info: EngineTransactionInfo) => Promise<T>, opts?: EngineTransactionOptions): Promise<T>;
-}
-
 // ── ImportFieldMapping (type) ──
 type ImportFieldMapping = z.input<typeof ImportFieldMappingSchema>;
 
diff --git a/packages/spec/api-surface/data.json b/packages/spec/api-surface/data.json
index ce4c20e4182..83b8cb5cb81 100644
--- a/packages/spec/api-surface/data.json
+++ b/packages/spec/api-surface/data.json
@@ -365,7 +365,6 @@
     "IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES (const)",
-    "IScopedContext (interface)",
     "ImportFieldMapping (type)",
     "ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema (const)",
diff --git a/packages/spec/export-origins/data.json b/packages/spec/export-origins/data.json
index 023cde93767..2d2d8fe072a 100644
--- a/packages/spec/export-origins/data.json
+++ b/packages/spec/export-origins/data.json
@@ -355,7 +355,6 @@
     "IMPORT_REFERENCE_TYPES": "src/data/import-coercion.ts#IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED": "src/data/driver/common.zod.ts#INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES": "src/data/field-value.zod.ts#INSTANT_TYPES (const)",
-    "IScopedContext": "src/contracts/scoped-context.ts#IScopedContext (interface)",
     "ImportFieldMapping": "src/data/mapping.zod.ts#ImportFieldMapping (type)",
     "ImportFieldMappingParsed": "src/data/mapping.zod.ts#ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema": "src/data/mapping.zod.ts#ImportFieldMappingSchema (const)",
diff --git a/packages/spec/src/data/hook-api.test.ts b/packages/spec/src/data/hook-api.test.ts
index 955a9bbf076..bd9db9af2f6 100644
--- a/packages/spec/src/data/hook-api.test.ts
+++ b/packages/spec/src/data/hook-api.test.ts
@@ -59,8 +59,6 @@ import type {
   HookObjectApi,
   HookQuery,
   HookUpdateOptions,
-  IScopedContext as ReExportedScopedContext,
-  IScopedObjectRepository as ReExportedScopedRepository,
 } from './hook-api';
 import type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';
 
@@ -191,20 +189,10 @@ describe('HookApi — the published hook ctx.api face', () => {
     // `@objectstack/spec/data` and emitting declarations answers TS2883 without
     // them, and `check:entry-nameability` cannot see it (it probes the call
     // surface of VALUE exports; `HookApi` is a type).
-    it('the transaction signature\'s two types, and the ctx.api pair', () => {
+    it('both types the transaction signature references', () => {
       const infoIsReachable: Assignable<EngineTransactionInfo, EngineTransactionInfo> = true;
       const optsIsReachable: Assignable<EngineTransactionOptions, EngineTransactionOptions> = true;
-      // Same declaration, reached through both entries — one declaration, two
-      // paths, which is what `check:dual-source-exports` asks about.
-      const oneDeclaration: Assignable<ReExportedScopedContext, IScopedContext> = true;
-      const andBack: Assignable<IScopedContext, ReExportedScopedContext> = true;
-      // The repository comes with it: `IScopedContext.object(name)` returns it,
-      // so exporting the context without it is a HALF closure — measured as a
-      // surviving TS2883 on `ctx.api.object(...)`.
-      const repoReachable: Assignable<ReExportedScopedRepository, IScopedObjectRepository> = true;
-      expect([infoIsReachable, optsIsReachable, oneDeclaration, andBack, repoReachable]).toEqual([
-        true, true, true, true, true,
-      ]);
+      expect([infoIsReachable, optsIsReachable]).toEqual([true, true]);
     });
   });
 
diff --git a/packages/spec/src/data/hook-api.ts b/packages/spec/src/data/hook-api.ts
index 281b6c98750..e609e67917c 100644
--- a/packages/spec/src/data/hook-api.ts
+++ b/packages/spec/src/data/hook-api.ts
@@ -328,24 +328,36 @@ export interface HookApi {
  * ```
  *
  * The second position — `transaction`'s `opts` — answers the same way for
- * `EngineTransactionOptions`. Those two are the blocking finding.
- *
- * The other two names close the SAME defect one frame out, and they come as a
- * PAIR because that is what the measurement said. `HookContext.api` has leaked
- * `IScopedContext` since #5945, and exporting that name alone is a HALF
- * closure: `IScopedContext.object(name)` returns `IScopedObjectRepository`, so
- * with three names `(ctx) => ctx.api!.object('deal')` still answered TS2883 on
- * that fourth name. With all four, a probe carrying every position — both
- * `transaction` arguments, `ctx.api`, `ctx.api.object(…)`, `api.object(…)` and
- * a repository read — emits at exit 0, and the emitted declarations resolve
- * every inferred type through `@objectstack/spec/data`. The chain terminates
- * there: the repository's own members answer in structural types
- * (`Promise` of `Record` of `string` to `any`, or `null`) that name nothing
- * further. Taken in one stroke because leaving it publishes a hook seam whose
- * own `ctx.api` cannot be named from the entry that publishes the seam — the
- * exact gap this card was opened to close — and because all four are one-line
- * re-exports in this file, of declarations `@objectstack/spec/contracts`
- * already publishes, adding no gate beyond the three this diff regenerates.
+ * `EngineTransactionOptions`. Those two are what this card owes, and they are
+ * what this file exports: they are names THIS card's own new declarations
+ * introduced to the entry.
+ *
+ * ⛔ A THIRD instance of the same defect is deliberately NOT closed here, and
+ * the reason is a measurement rather than a scope reflex. `HookContext.api` has
+ * leaked `IScopedContext` off this entry since #5945 — pre-existing, present on
+ * this card's base and unchanged by it. Closing it is not the one-line job it
+ * looks like:
+ *
+ *   - It needs TWO names, not one. `IScopedContext.object(name)` returns
+ *     `IScopedObjectRepository`, so with `IScopedContext` exported alone a
+ *     consumer writing `ctx.api.object('deal')` still answers TS2883 on the
+ *     repository — measured, at head, with the three-name variant applied. A
+ *     one-name patch publishes a HALF closure that READS closed, which is the
+ *     declared-not-enforced shape this repo refuses.
+ *   - The second of those two names is not free. Adding
+ *     `IScopedObjectRepository` to this entry moves the dts bundler's module
+ *     order enough to reorder members inside object type literals in the
+ *     UNRELATED `ui` shard: 330 lines, which `check:api-surface-declarations`
+ *     reports as "33 reshaped" and asks a reviewer to rule on. Measured as
+ *     order-only — identical token multiset, identical line count, nothing
+ *     added, removed or renamed — and the generator is stable against a fixed
+ *     dist, so it is noise rather than drift. But it is a verdict somebody has
+ *     to read, in a shard this card does not touch.
+ *
+ * Two names with a clean surface delta, or four names plus an adjudication in
+ * someone else's shard: that is a trade for its own card and its own review,
+ * not a rider on a FAIL remediation. The pre-existing leak is reported with
+ * both measurements so that card can be written without re-deriving them.
  *
  * ⛔ `check:entry-nameability` is NOT the instrument that answers this. By its
  * own docblock it probes the CALL surface of VALUE exports that have a call
@@ -355,9 +367,8 @@ export interface HookApi {
  * are a known target outside it. The instrument that answers is a consumer
  * program with `declaration` emit, which is what the excerpt above is.
  *
- * Type-only re-exports: they add four names to this entry and no runtime byte,
+ * Type-only re-exports: they add two names to this entry and no runtime byte,
  * and each is ONE declaration reachable from two entries rather than two
  * declarations sharing a name, which is what `check:dual-source-exports` asks.
  */
 export type { EngineTransactionInfo, EngineTransactionOptions } from '../contracts/objectql-engine';
-export type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';

From b3ecf8e3f2e3e1f0faeaf2bf10194a81fa17935c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 16:19:58 +0000
Subject: [PATCH 09/11] chore(spec): regenerate the declaration shards from the
 merged tree

Discharges the merge deferral from d95e7cf77d. `data.txt` carries this
branch's eleven additions on top of what main brought; `ui.txt` and
`automation.txt` moved order-only (identical token multiset, identical line
count, nothing added, removed or renamed).

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../api-surface-declarations/automation.txt   |  48 +-
 .../spec/api-surface-declarations/data.txt    | 976 +++++++++---------
 packages/spec/api-surface-declarations/ui.txt | 330 +++---
 3 files changed, 671 insertions(+), 683 deletions(-)

diff --git a/packages/spec/api-surface-declarations/automation.txt b/packages/spec/api-surface-declarations/automation.txt
index dcb0b9bfb53..834d58c8d10 100644
--- a/packages/spec/api-surface-declarations/automation.txt
+++ b/packages/spec/api-surface-declarations/automation.txt
@@ -139,8 +139,8 @@ declare const ActionCategorySchema: z.ZodEnum<{
     io: "io";
     control: "control";
     data: "data";
-    human: "human";
     logic: "logic";
+    human: "human";
 }>;
 
 // ── ActionDescriptor (type) ──
@@ -161,8 +161,8 @@ declare const ActionDescriptorSchema: z.ZodObject<{
         io: "io";
         control: "control";
         data: "data";
-        human: "human";
         logic: "logic";
+        human: "human";
     }>>;
     paradigms: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         flow: "flow";
@@ -188,8 +188,8 @@ declare const ActionDescriptorSchema: z.ZodObject<{
         reserved: "reserved";
     }>>;
     source: z.ZodDefault<z.ZodEnum<{
-        plugin: "plugin";
         builtin: "builtin";
+        plugin: "plugin";
     }>>;
     deprecated: z.ZodDefault<z.ZodBoolean>;
     aliasOf: z.ZodOptional<z.ZodString>;
@@ -805,13 +805,13 @@ declare const ExecutionLogSchema: z.ZodObject<{
     flowName: z.ZodString;
     flowVersion: z.ZodOptional<z.ZodNumber>;
     status: z.ZodEnum<{
-        failed: "failed";
+        completed: "completed";
         refused: "refused";
         pending: "pending";
-        completed: "completed";
         running: "running";
-        cancelled: "cancelled";
         paused: "paused";
+        failed: "failed";
+        cancelled: "cancelled";
         timed_out: "timed_out";
         retrying: "retrying";
     }>;
@@ -829,8 +829,8 @@ declare const ExecutionLogSchema: z.ZodObject<{
         nodeLabel: z.ZodOptional<z.ZodString>;
         status: z.ZodEnum<{
             success: "success";
-            skipped: "skipped";
             failure: "failure";
+            skipped: "skipped";
         }>;
         startedAt: z.ZodString;
         completedAt: z.ZodOptional<z.ZodString>;
@@ -871,8 +871,8 @@ declare const ExecutionLogSchema: z.ZodObject<{
             nodeLabel: z.ZodOptional<z.ZodString>;
             status: z.ZodEnum<{
                 success: "success";
-                skipped: "skipped";
                 failure: "failure";
+                skipped: "skipped";
             }>;
             runs: z.ZodNumber;
             failures: z.ZodNumber;
@@ -903,13 +903,13 @@ declare const ExecutionLogSchema: z.ZodObject<{
 
 // ── ExecutionStatus (const) ──
 declare const ExecutionStatus: z.ZodEnum<{
-    failed: "failed";
+    completed: "completed";
     refused: "refused";
     pending: "pending";
-    completed: "completed";
     running: "running";
-    cancelled: "cancelled";
     paused: "paused";
+    failed: "failed";
+    cancelled: "cancelled";
     timed_out: "timed_out";
     retrying: "retrying";
 }>;
@@ -930,8 +930,8 @@ declare const ExecutionStepLogSchema: z.ZodObject<{
     nodeLabel: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
         success: "success";
-        skipped: "skipped";
         failure: "failure";
+        skipped: "skipped";
     }>;
     startedAt: z.ZodString;
     completedAt: z.ZodOptional<z.ZodString>;
@@ -1585,8 +1585,8 @@ declare const FlowRunNodeSummarySchema: z.ZodObject<{
     nodeLabel: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
         success: "success";
-        skipped: "skipped";
         failure: "failure";
+        skipped: "skipped";
     }>;
     runs: z.ZodNumber;
     failures: z.ZodNumber;
@@ -1615,8 +1615,8 @@ declare const FlowRunSummarySchema: z.ZodObject<{
         nodeLabel: z.ZodOptional<z.ZodString>;
         status: z.ZodEnum<{
             success: "success";
-            skipped: "skipped";
             failure: "failure";
+            skipped: "skipped";
         }>;
         runs: z.ZodNumber;
         failures: z.ZodNumber;
@@ -2909,20 +2909,20 @@ declare const ScheduleStateSchema: z.ZodObject<{
     status: z.ZodDefault<z.ZodEnum<{
         disabled: "disabled";
         active: "active";
-        expired: "expired";
         paused: "paused";
+        expired: "expired";
     }>>;
     nextRunAt: z.ZodOptional<z.ZodString>;
     lastRunAt: z.ZodOptional<z.ZodString>;
     lastExecutionId: z.ZodOptional<z.ZodString>;
     lastRunStatus: z.ZodOptional<z.ZodEnum<{
-        failed: "failed";
+        completed: "completed";
         refused: "refused";
         pending: "pending";
-        completed: "completed";
         running: "running";
-        cancelled: "cancelled";
         paused: "paused";
+        failed: "failed";
+        cancelled: "cancelled";
         timed_out: "timed_out";
         retrying: "retrying";
     }>>;
@@ -3508,10 +3508,10 @@ type WaitEventType = z.input<typeof WaitEventTypeSchema>;
 // ── WaitEventTypeSchema (const) ──
 declare const WaitEventTypeSchema: z.ZodEnum<{
     condition: "condition";
-    manual: "manual";
-    webhook: "webhook";
     timer: "timer";
     signal: "signal";
+    webhook: "webhook";
+    manual: "manual";
 }>;
 
 // ── WaitExecutorConfig (type) ──
@@ -3525,8 +3525,8 @@ declare const WaitExecutorConfigSchema: z.ZodObject<{
     defaultTimeoutMs: z.ZodDefault<z.ZodNumber>;
     defaultTimeoutBehavior: z.ZodDefault<z.ZodEnum<{
         continue: "continue";
-        fail: "fail";
         fallback: "fallback";
+        fail: "fail";
     }>>;
     conditionPollIntervalMs: z.ZodDefault<z.ZodNumber>;
     conditionMaxPolls: z.ZodDefault<z.ZodNumber>;
@@ -3545,10 +3545,10 @@ declare const WaitResumePayloadSchema: z.ZodObject<{
     nodeId: z.ZodString;
     eventType: z.ZodEnum<{
         condition: "condition";
-        manual: "manual";
-        webhook: "webhook";
         timer: "timer";
         signal: "signal";
+        webhook: "webhook";
+        manual: "manual";
     }>;
     signalName: z.ZodOptional<z.ZodString>;
     webhookPayload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3563,8 +3563,8 @@ type WaitTimeoutBehavior = z.input<typeof WaitTimeoutBehaviorSchema>;
 // ── WaitTimeoutBehaviorSchema (const) ──
 declare const WaitTimeoutBehaviorSchema: z.ZodEnum<{
     continue: "continue";
-    fail: "fail";
     fallback: "fallback";
+    fail: "fail";
 }>;
 
 // ── Webhook (type) ──
diff --git a/packages/spec/api-surface-declarations/data.txt b/packages/spec/api-surface-declarations/data.txt
index d3e7d364cf5..3ac7d745a6f 100644
--- a/packages/spec/api-surface-declarations/data.txt
+++ b/packages/spec/api-surface-declarations/data.txt
@@ -774,7 +774,7 @@ declare const ConditionalValidationSchema: z.ZodObject<{
     type: z.ZodLiteral<"conditional">;
     when: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -786,12 +786,12 @@ declare const ConditionalValidationSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>;
     then: z.ZodType<BaseValidationRuleShape, BaseValidationRuleShape, z.core.$ZodTypeInternals<BaseValidationRuleShape, BaseValidationRuleShape>>;
     otherwise: z.ZodOptional<z.ZodType<BaseValidationRuleShape, BaseValidationRuleShape, z.core.$ZodTypeInternals<BaseValidationRuleShape, BaseValidationRuleShape>>>;
@@ -869,7 +869,7 @@ declare const CrossFieldValidationSchema: z.ZodObject<{
     type: z.ZodLiteral<"cross_field">;
     condition: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -881,12 +881,12 @@ declare const CrossFieldValidationSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>;
     fields: z.ZodArray<z.ZodString>;
     _lock: z.ZodOptional<z.ZodEnum<{
@@ -977,12 +977,6 @@ type CubeJoinParsed = z.infer<typeof CubeJoinSchema>;
 // ── CubeJoinSchema (const) ──
 declare const CubeJoinSchema: z.ZodObject<{
     name: z.ZodString;
-    relationship: z.ZodDefault<z.ZodEnum<{
-        one_to_one: "one_to_one";
-        one_to_many: "one_to_many";
-        many_to_one: "many_to_one";
-    }>>;
-    sql: z.ZodString;
 }, z.core.$strict>;
 
 // ── CubeParsed (type) ──
@@ -1054,12 +1048,6 @@ declare const CubeSchema: z.ZodObject<{
     }, z.core.$strict>>;
     joins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         name: z.ZodString;
-        relationship: z.ZodDefault<z.ZodEnum<{
-            one_to_one: "one_to_one";
-            one_to_many: "one_to_many";
-            many_to_one: "many_to_one";
-        }>>;
-        sql: z.ZodString;
     }, z.core.$strict>>>;
     refreshKey: z.ZodOptional<z.ZodObject<{
         every: z.ZodOptional<z.ZodString>;
@@ -6507,7 +6495,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6522,7 +6510,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6531,7 +6519,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6555,7 +6543,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6579,7 +6567,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6625,7 +6613,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6634,7 +6622,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6697,7 +6685,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6712,7 +6700,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6721,7 +6709,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6745,7 +6733,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6769,7 +6757,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6815,7 +6803,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6824,7 +6812,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6887,7 +6875,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -6902,7 +6890,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6911,7 +6899,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6935,7 +6923,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -6959,7 +6947,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7005,7 +6993,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7014,7 +7002,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7077,7 +7065,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7092,7 +7080,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7101,7 +7089,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7125,7 +7113,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7149,7 +7137,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7195,7 +7183,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7204,7 +7192,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7267,7 +7255,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7282,7 +7270,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7291,7 +7279,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7315,7 +7303,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7339,7 +7327,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7385,7 +7373,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7394,7 +7382,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7457,7 +7445,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7472,7 +7460,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7481,7 +7469,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7505,7 +7493,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7529,7 +7517,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7575,7 +7563,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7584,7 +7572,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7647,7 +7635,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7662,7 +7650,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7671,7 +7659,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7695,7 +7683,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7719,7 +7707,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7765,7 +7753,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7774,7 +7762,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7837,7 +7825,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7852,7 +7840,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7861,7 +7849,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7885,7 +7873,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7909,7 +7897,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -7955,7 +7943,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -7964,7 +7952,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8027,7 +8015,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8042,7 +8030,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8051,7 +8039,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8075,7 +8063,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8099,7 +8087,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8145,7 +8133,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8154,7 +8142,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8217,7 +8205,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8232,7 +8220,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8241,7 +8229,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8265,7 +8253,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8289,7 +8277,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8335,7 +8323,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8344,7 +8332,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8407,7 +8395,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8422,7 +8410,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8431,7 +8419,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8455,7 +8443,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8479,7 +8467,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8525,7 +8513,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8534,7 +8522,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8597,7 +8585,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8612,7 +8600,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8621,7 +8609,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8645,7 +8633,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8669,7 +8657,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8715,7 +8703,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8724,7 +8712,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8787,7 +8775,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8802,7 +8790,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8811,7 +8799,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8835,7 +8823,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8859,7 +8847,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -8905,7 +8893,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8914,7 +8902,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8977,7 +8965,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -8992,7 +8980,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9001,7 +8989,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9025,7 +9013,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9049,7 +9037,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9095,7 +9083,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9104,7 +9092,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9167,7 +9155,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9182,7 +9170,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9191,7 +9179,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9215,7 +9203,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9239,7 +9227,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9285,7 +9273,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9294,7 +9282,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9357,7 +9345,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9372,7 +9360,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9381,7 +9369,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9405,7 +9393,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9429,7 +9417,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9475,7 +9463,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9484,7 +9472,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9547,7 +9535,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9562,7 +9550,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9571,7 +9559,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9595,7 +9583,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9619,7 +9607,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9665,7 +9653,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9674,7 +9662,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9760,7 +9748,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9775,7 +9763,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9784,7 +9772,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9808,7 +9796,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9832,7 +9820,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9878,7 +9866,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9887,7 +9875,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9950,7 +9938,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -9965,7 +9953,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9974,7 +9962,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -9998,7 +9986,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10022,7 +10010,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10068,7 +10056,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10077,7 +10065,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10140,7 +10128,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10155,7 +10143,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10164,7 +10152,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10188,7 +10176,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10212,7 +10200,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10258,7 +10246,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10267,7 +10255,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10330,7 +10318,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10345,7 +10333,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10354,7 +10342,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10378,7 +10366,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10402,7 +10390,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10448,7 +10436,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10457,7 +10445,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10526,7 +10514,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10541,7 +10529,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10550,7 +10538,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10574,7 +10562,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10598,7 +10586,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10644,7 +10632,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10653,7 +10641,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10734,7 +10722,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10749,7 +10737,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10758,7 +10746,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10782,7 +10770,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10806,7 +10794,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10852,7 +10840,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10861,7 +10849,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10939,7 +10927,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -10954,7 +10942,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10963,7 +10951,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -10987,7 +10975,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11011,7 +10999,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11057,7 +11045,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11066,7 +11054,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11144,7 +11132,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11159,7 +11147,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11168,7 +11156,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11192,7 +11180,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11216,7 +11204,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11262,7 +11250,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11271,7 +11259,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11334,7 +11322,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11349,7 +11337,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11358,7 +11346,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11382,7 +11370,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11406,7 +11394,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11452,7 +11440,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11461,7 +11449,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11524,7 +11512,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11539,7 +11527,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11548,7 +11536,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11572,7 +11560,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11596,7 +11584,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11642,7 +11630,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11651,7 +11639,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11714,7 +11702,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11729,7 +11717,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11738,7 +11726,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11762,7 +11750,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11786,7 +11774,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11832,7 +11820,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11841,7 +11829,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11904,7 +11892,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -11919,7 +11907,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11928,7 +11916,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11952,7 +11940,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -11976,7 +11964,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12022,7 +12010,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12031,7 +12019,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12094,7 +12082,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12109,7 +12097,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12118,7 +12106,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12142,7 +12130,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12166,7 +12154,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12212,7 +12200,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12221,7 +12209,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12284,7 +12272,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12299,7 +12287,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12308,7 +12296,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12332,7 +12320,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12356,7 +12344,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12402,7 +12390,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12411,7 +12399,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12474,7 +12462,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12489,7 +12477,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12498,7 +12486,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12522,7 +12510,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12546,7 +12534,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12592,7 +12580,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12601,7 +12589,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12664,7 +12652,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12679,7 +12667,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12688,7 +12676,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12712,7 +12700,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12736,7 +12724,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12782,7 +12770,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12791,7 +12779,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12854,7 +12842,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12869,7 +12857,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12878,7 +12866,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12902,7 +12890,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12926,7 +12914,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -12972,7 +12960,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -12981,7 +12969,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13044,7 +13032,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13059,7 +13047,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13068,7 +13056,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13092,7 +13080,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13116,7 +13104,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13162,7 +13150,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13171,7 +13159,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13234,7 +13222,7 @@ declare const Field: {
             default?: boolean | undefined;
             visibleWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13249,7 +13237,7 @@ declare const Field: {
         readonly required?: boolean | undefined;
         readonly visibleWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13258,7 +13246,7 @@ declare const Field: {
         } | undefined;
         readonly readonlyWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13282,7 +13270,7 @@ declare const Field: {
         readonly deleteBehavior?: "set_null" | "cascade" | "restrict" | undefined;
         readonly expression?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13306,7 +13294,7 @@ declare const Field: {
         readonly accept?: string[] | undefined;
         readonly requiredWhen?: string | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13352,7 +13340,7 @@ declare const Field: {
             autofill?: boolean | undefined;
             readonlyWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13361,7 +13349,7 @@ declare const Field: {
             } | undefined;
             requiredWhen?: string | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -13650,7 +13638,7 @@ declare const FieldSchema: z.ZodObject<{
         default: z.ZodOptional<z.ZodBoolean>;
         visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13662,12 +13650,12 @@ declare const FieldSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
     }, z.core.$strict>>>;
     reference: z.ZodOptional<z.ZodString>;
@@ -13716,7 +13704,7 @@ declare const FieldSchema: z.ZodObject<{
         autofill: z.ZodOptional<z.ZodBoolean>;
         readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13728,16 +13716,16 @@ declare const FieldSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -13749,12 +13737,12 @@ declare const FieldSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
     }, z.core.$strict>>>;
     inlineAmountField: z.ZodOptional<z.ZodString>;
@@ -13793,7 +13781,7 @@ declare const FieldSchema: z.ZodObject<{
     allowCreate: z.ZodOptional<z.ZodBoolean>;
     expression: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -13805,12 +13793,12 @@ declare const FieldSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     returnType: z.ZodOptional<z.ZodEnum<{
         number: "number";
@@ -13846,7 +13834,7 @@ declare const FieldSchema: z.ZodObject<{
     group: z.ZodOptional<z.ZodString>;
     visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -13858,16 +13846,16 @@ declare const FieldSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -13879,16 +13867,16 @@ declare const FieldSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -13900,12 +13888,12 @@ declare const FieldSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     conditionalRequired: z.ZodOptional<z.ZodNever>;
     widget: z.ZodOptional<z.ZodString>;
@@ -14573,7 +14561,7 @@ declare const HookSchema: z.ZodObject<{
     async: z.ZodDefault<z.ZodBoolean>;
     condition: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -14585,12 +14573,12 @@ declare const HookSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     description: z.ZodOptional<z.ZodString>;
     retryPolicy: z.ZodOptional<z.ZodObject<{
@@ -14733,7 +14721,7 @@ declare const InlineGridColumnSchema: z.ZodObject<{
     autofill: z.ZodOptional<z.ZodBoolean>;
     readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -14745,16 +14733,16 @@ declare const InlineGridColumnSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -14766,12 +14754,12 @@ declare const InlineGridColumnSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strict>;
 
@@ -15728,7 +15716,7 @@ declare const ObjectExtensionSchema: z.ZodObject<{
             default: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -15740,12 +15728,12 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>>>;
         reference: z.ZodOptional<z.ZodString>;
@@ -15794,7 +15782,7 @@ declare const ObjectExtensionSchema: z.ZodObject<{
             autofill: z.ZodOptional<z.ZodBoolean>;
             readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -15806,16 +15794,16 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -15827,12 +15815,12 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>>>;
         inlineAmountField: z.ZodOptional<z.ZodString>;
@@ -15871,7 +15859,7 @@ declare const ObjectExtensionSchema: z.ZodObject<{
         allowCreate: z.ZodOptional<z.ZodBoolean>;
         expression: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -15883,12 +15871,12 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         returnType: z.ZodOptional<z.ZodEnum<{
             number: "number";
@@ -15924,7 +15912,7 @@ declare const ObjectExtensionSchema: z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
         visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -15936,16 +15924,16 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -15957,16 +15945,16 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -15978,12 +15966,12 @@ declare const ObjectExtensionSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         conditionalRequired: z.ZodOptional<z.ZodNever>;
         widget: z.ZodOptional<z.ZodString>;
@@ -16053,7 +16041,7 @@ declare const ObjectFieldGroupSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -16065,12 +16053,12 @@ declare const ObjectFieldGroupSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     collapse: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         none: "none";
@@ -16156,7 +16144,7 @@ declare const ObjectSchema: z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16168,16 +16156,16 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16189,19 +16177,19 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>]>>;
         import: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16213,16 +16201,16 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16234,19 +16222,19 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>]>>;
         edit: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16258,16 +16246,16 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16279,19 +16267,19 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>]>>;
         delete: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16303,16 +16291,16 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16324,12 +16312,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>]>>;
         exportCsv: z.ZodOptional<z.ZodBoolean>;
@@ -16454,7 +16442,7 @@ declare const ObjectSchema: z.ZodObject<{
             default: z.ZodOptional<z.ZodBoolean>;
             visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16466,12 +16454,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>>>;
         reference: z.ZodOptional<z.ZodString>;
@@ -16520,7 +16508,7 @@ declare const ObjectSchema: z.ZodObject<{
             autofill: z.ZodOptional<z.ZodBoolean>;
             readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16532,16 +16520,16 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -16553,12 +16541,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
         }, z.core.$strict>>>;
         inlineAmountField: z.ZodOptional<z.ZodString>;
@@ -16597,7 +16585,7 @@ declare const ObjectSchema: z.ZodObject<{
         allowCreate: z.ZodOptional<z.ZodBoolean>;
         expression: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -16609,12 +16597,12 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         returnType: z.ZodOptional<z.ZodEnum<{
             number: "number";
@@ -16650,7 +16638,7 @@ declare const ObjectSchema: z.ZodObject<{
         group: z.ZodOptional<z.ZodString>;
         visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -16662,16 +16650,16 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         readonlyWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -16683,16 +16671,16 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         requiredWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -16704,12 +16692,12 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         conditionalRequired: z.ZodOptional<z.ZodNever>;
         widget: z.ZodOptional<z.ZodString>;
@@ -16749,7 +16737,7 @@ declare const ObjectSchema: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -16761,12 +16749,12 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>>;
         collapse: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             none: "none";
@@ -17073,7 +17061,7 @@ declare const ObjectSchema: z.ZodObject<{
             confirmLabel: z.ZodOptional<z.ZodString>;
             visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -17085,12 +17073,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             maxRecords: z.ZodOptional<z.ZodNumber>;
@@ -17509,7 +17497,7 @@ declare const ObjectSchema: z.ZodObject<{
         conditionalFormatting: z.ZodOptional<z.ZodArray<z.ZodObject<{
             condition: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -17521,12 +17509,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>;
             style: z.ZodRecord<z.ZodString, z.ZodString>;
         }, z.core.$strict>>>;
@@ -17823,7 +17811,7 @@ declare const ObjectSchema: z.ZodObject<{
                 value: z.ZodString;
                 visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -17835,12 +17823,12 @@ declare const ObjectSchema: z.ZodObject<{
                         cron: "cron";
                         template: "template";
                     }>;
-                    source: z.ZodOptional<z.ZodString>;
                     ast: z.ZodOptional<z.ZodUnknown>;
                     meta: z.ZodOptional<z.ZodObject<{
                         rationale: z.ZodOptional<z.ZodString>;
                         generatedBy: z.ZodOptional<z.ZodString>;
                     }, z.core.$strip>>;
+                    source: z.ZodString;
                 }, z.core.$strip>]>>;
             }, z.core.$strict>>>;
             placeholder: z.ZodOptional<z.ZodString>;
@@ -17854,7 +17842,7 @@ declare const ObjectSchema: z.ZodObject<{
             carryOver: z.ZodOptional<z.ZodBoolean>;
             visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -17866,12 +17854,12 @@ declare const ObjectSchema: z.ZodObject<{
                     cron: "cron";
                     template: "template";
                 }>;
-                source: z.ZodOptional<z.ZodString>;
                 ast: z.ZodOptional<z.ZodUnknown>;
                 meta: z.ZodOptional<z.ZodObject<{
                     rationale: z.ZodOptional<z.ZodString>;
                     generatedBy: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
+                source: z.ZodString;
             }, z.core.$strip>]>>;
             requiresFeature: z.ZodOptional<z.ZodEnum<{
                 organization: "organization";
@@ -17904,7 +17892,7 @@ declare const ObjectSchema: z.ZodObject<{
                 value: string;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -17912,7 +17900,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -17931,7 +17919,7 @@ declare const ObjectSchema: z.ZodObject<{
             carryOver?: boolean | undefined;
             visible?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -17939,7 +17927,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -17965,7 +17953,7 @@ declare const ObjectSchema: z.ZodObject<{
                 value: string;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -17973,7 +17961,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -17992,7 +17980,7 @@ declare const ObjectSchema: z.ZodObject<{
             carryOver?: boolean | undefined;
             visible?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18000,7 +17988,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18131,7 +18119,7 @@ declare const ObjectSchema: z.ZodObject<{
         }, z.core.$strict>>;
         visible: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18143,12 +18131,12 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>]>>;
         requiresFeature: z.ZodOptional<z.ZodEnum<{
             organization: "organization";
@@ -18165,7 +18153,7 @@ declare const ObjectSchema: z.ZodObject<{
         }>>;
         disabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18177,12 +18165,12 @@ declare const ObjectSchema: z.ZodObject<{
                 cron: "cron";
                 template: "template";
             }>;
-            source: z.ZodOptional<z.ZodString>;
             ast: z.ZodOptional<z.ZodUnknown>;
             meta: z.ZodOptional<z.ZodObject<{
                 rationale: z.ZodOptional<z.ZodString>;
                 generatedBy: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
+            source: z.ZodString;
         }, z.core.$strip>]>]>>;
         requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         shortcut: z.ZodOptional<z.ZodNever>;
@@ -18308,7 +18296,7 @@ declare const ObjectSchema: z.ZodObject<{
                 value: string;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18316,7 +18304,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18335,7 +18323,7 @@ declare const ObjectSchema: z.ZodObject<{
             carryOver?: boolean | undefined;
             visible?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18343,7 +18331,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18392,7 +18380,7 @@ declare const ObjectSchema: z.ZodObject<{
         } | undefined;
         visible?: boolean | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18400,7 +18388,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18410,7 +18398,7 @@ declare const ObjectSchema: z.ZodObject<{
         requiresFeature?: "organization" | "admin" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "phoneNumber" | "phoneNumberOtp" | undefined;
         disabled?: boolean | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18418,7 +18406,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18519,7 +18507,7 @@ declare const ObjectSchema: z.ZodObject<{
                 value: string;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18527,7 +18515,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18546,7 +18534,7 @@ declare const ObjectSchema: z.ZodObject<{
             carryOver?: boolean | undefined;
             visible?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18554,7 +18542,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18603,7 +18591,7 @@ declare const ObjectSchema: z.ZodObject<{
         } | undefined;
         visible?: boolean | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18611,7 +18599,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18621,7 +18609,7 @@ declare const ObjectSchema: z.ZodObject<{
         requiresFeature?: "organization" | "admin" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "phoneNumber" | "phoneNumberOtp" | undefined;
         disabled?: boolean | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18629,7 +18617,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -18738,7 +18726,7 @@ declare const ObjectSchema: z.ZodObject<{
                 default?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18746,7 +18734,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18783,7 +18771,7 @@ declare const ObjectSchema: z.ZodObject<{
                 autofill?: boolean | undefined;
                 readonlyWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18791,7 +18779,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18800,7 +18788,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 requiredWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18808,7 +18796,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18842,7 +18830,7 @@ declare const ObjectSchema: z.ZodObject<{
             allowCreate?: boolean | undefined;
             expression?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18850,7 +18838,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18877,7 +18865,7 @@ declare const ObjectSchema: z.ZodObject<{
             group?: string | undefined;
             visibleWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18885,7 +18873,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18894,7 +18882,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             readonlyWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18902,7 +18890,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18911,7 +18899,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             requiredWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18919,7 +18907,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -18958,7 +18946,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18966,7 +18954,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18975,7 +18963,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18983,7 +18971,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -18995,7 +18983,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19003,7 +18991,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19012,7 +19000,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19020,7 +19008,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19032,7 +19020,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19040,7 +19028,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19049,7 +19037,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19057,7 +19045,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19069,7 +19057,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19077,7 +19065,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19086,7 +19074,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19094,7 +19082,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19131,7 +19119,7 @@ declare const ObjectSchema: z.ZodObject<{
             description?: string | undefined;
             visibleWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19139,7 +19127,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19324,7 +19312,7 @@ declare const ObjectSchema: z.ZodObject<{
                 confirmLabel?: string | undefined;
                 visible?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19332,7 +19320,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19559,7 +19547,7 @@ declare const ObjectSchema: z.ZodObject<{
             conditionalFormatting?: {
                 condition: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19567,7 +19555,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19684,7 +19672,7 @@ declare const ObjectSchema: z.ZodObject<{
                     value: string;
                     visibleWhen?: {
                         dialect: "cel" | "cron" | "template";
-                        source?: string | undefined;
+                        source: string;
                         ast?: unknown;
                         meta?: {
                             rationale?: string | undefined;
@@ -19692,7 +19680,7 @@ declare const ObjectSchema: z.ZodObject<{
                         } | undefined;
                     } | {
                         dialect: "cel" | "cron" | "template";
-                        source?: string | undefined;
+                        source: string;
                         ast?: unknown;
                         meta?: {
                             rationale?: string | undefined;
@@ -19711,7 +19699,7 @@ declare const ObjectSchema: z.ZodObject<{
                 carryOver?: boolean | undefined;
                 visible?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19719,7 +19707,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19768,7 +19756,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             visible?: boolean | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19776,7 +19764,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19786,7 +19774,7 @@ declare const ObjectSchema: z.ZodObject<{
             requiresFeature?: "organization" | "admin" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "phoneNumber" | "phoneNumberOtp" | undefined;
             disabled?: boolean | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19794,7 +19782,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -19893,7 +19881,7 @@ declare const ObjectSchema: z.ZodObject<{
                 default?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19901,7 +19889,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19938,7 +19926,7 @@ declare const ObjectSchema: z.ZodObject<{
                 autofill?: boolean | undefined;
                 readonlyWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19946,7 +19934,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19955,7 +19943,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 requiredWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19963,7 +19951,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -19997,7 +19985,7 @@ declare const ObjectSchema: z.ZodObject<{
             allowCreate?: boolean | undefined;
             expression?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20005,7 +19993,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20032,7 +20020,7 @@ declare const ObjectSchema: z.ZodObject<{
             group?: string | undefined;
             visibleWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20040,7 +20028,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20049,7 +20037,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             readonlyWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20057,7 +20045,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20066,7 +20054,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             requiredWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20074,7 +20062,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20113,7 +20101,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20121,7 +20109,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20130,7 +20118,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20138,7 +20126,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20150,7 +20138,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20158,7 +20146,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20167,7 +20155,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20175,7 +20163,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20187,7 +20175,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20195,7 +20183,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20204,7 +20192,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20212,7 +20200,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20224,7 +20212,7 @@ declare const ObjectSchema: z.ZodObject<{
                 enabled?: boolean | undefined;
                 visibleWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20232,7 +20220,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20241,7 +20229,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
                 disabledWhen?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20249,7 +20237,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20286,7 +20274,7 @@ declare const ObjectSchema: z.ZodObject<{
             description?: string | undefined;
             visibleWhen?: {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20294,7 +20282,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20479,7 +20467,7 @@ declare const ObjectSchema: z.ZodObject<{
                 confirmLabel?: string | undefined;
                 visible?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20487,7 +20475,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20714,7 +20702,7 @@ declare const ObjectSchema: z.ZodObject<{
             conditionalFormatting?: {
                 condition: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20722,7 +20710,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20839,7 +20827,7 @@ declare const ObjectSchema: z.ZodObject<{
                     value: string;
                     visibleWhen?: {
                         dialect: "cel" | "cron" | "template";
-                        source?: string | undefined;
+                        source: string;
                         ast?: unknown;
                         meta?: {
                             rationale?: string | undefined;
@@ -20847,7 +20835,7 @@ declare const ObjectSchema: z.ZodObject<{
                         } | undefined;
                     } | {
                         dialect: "cel" | "cron" | "template";
-                        source?: string | undefined;
+                        source: string;
                         ast?: unknown;
                         meta?: {
                             rationale?: string | undefined;
@@ -20866,7 +20854,7 @@ declare const ObjectSchema: z.ZodObject<{
                 carryOver?: boolean | undefined;
                 visible?: {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20874,7 +20862,7 @@ declare const ObjectSchema: z.ZodObject<{
                     } | undefined;
                 } | {
                     dialect: "cel" | "cron" | "template";
-                    source?: string | undefined;
+                    source: string;
                     ast?: unknown;
                     meta?: {
                         rationale?: string | undefined;
@@ -20923,7 +20911,7 @@ declare const ObjectSchema: z.ZodObject<{
             } | undefined;
             visible?: boolean | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20931,7 +20919,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20941,7 +20929,7 @@ declare const ObjectSchema: z.ZodObject<{
             requiresFeature?: "organization" | "admin" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "phoneNumber" | "phoneNumberOtp" | undefined;
             disabled?: boolean | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -20949,7 +20937,7 @@ declare const ObjectSchema: z.ZodObject<{
                 } | undefined;
             } | {
                 dialect: "cel" | "cron" | "template";
-                source?: string | undefined;
+                source: string;
                 ast?: unknown;
                 meta?: {
                     rationale?: string | undefined;
@@ -21590,7 +21578,7 @@ declare const RowCrudActionOverrideSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -21602,16 +21590,16 @@ declare const RowCrudActionOverrideSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
     disabledWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -21623,19 +21611,19 @@ declare const RowCrudActionOverrideSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strict>;
 
 // ── RowCrudPredicates (interface) ──
 interface RowCrudPredicates {
-    visibleWhen?: Expression | ExpressionInput;
-    disabledWhen?: Expression | ExpressionInput;
+    visibleWhen?: EvaluatedExpression | EvaluatedExpressionInput;
+    disabledWhen?: EvaluatedExpression | EvaluatedExpressionInput;
 }
 
 // ── SCALAR_FILTER_HEAD_TYPES (const) ──
@@ -21871,7 +21859,7 @@ declare const ScriptValidationSchema: z.ZodObject<{
     type: z.ZodLiteral<"script">;
     condition: z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -21883,12 +21871,12 @@ declare const ScriptValidationSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>;
     _lock: z.ZodOptional<z.ZodEnum<{
         none: "none";
@@ -22279,7 +22267,7 @@ declare const SelectOptionSchema: z.ZodObject<{
     default: z.ZodOptional<z.ZodBoolean>;
     visibleWhen: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodString, z.ZodTransform<{
         dialect: "cel" | "cron" | "template";
-        source?: string | undefined;
+        source: string;
         ast?: unknown;
         meta?: {
             rationale?: string | undefined;
@@ -22291,12 +22279,12 @@ declare const SelectOptionSchema: z.ZodObject<{
             cron: "cron";
             template: "template";
         }>;
-        source: z.ZodOptional<z.ZodString>;
         ast: z.ZodOptional<z.ZodUnknown>;
         meta: z.ZodOptional<z.ZodObject<{
             rationale: z.ZodOptional<z.ZodString>;
             generatedBy: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        source: z.ZodString;
     }, z.core.$strip>]>>;
 }, z.core.$strict>;
 
@@ -23078,7 +23066,7 @@ declare const fieldForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23086,7 +23074,7 @@ declare const fieldForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23095,7 +23083,7 @@ declare const fieldForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23103,7 +23091,7 @@ declare const fieldForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23126,7 +23114,7 @@ declare const fieldForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23134,7 +23122,7 @@ declare const fieldForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23143,7 +23131,7 @@ declare const fieldForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23151,7 +23139,7 @@ declare const fieldForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23323,7 +23311,7 @@ declare const hookForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23331,7 +23319,7 @@ declare const hookForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23340,7 +23328,7 @@ declare const hookForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23348,7 +23336,7 @@ declare const hookForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23371,7 +23359,7 @@ declare const hookForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23379,7 +23367,7 @@ declare const hookForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23388,7 +23376,7 @@ declare const hookForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23396,7 +23384,7 @@ declare const hookForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23652,7 +23640,7 @@ declare const objectForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23660,7 +23648,7 @@ declare const objectForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23669,7 +23657,7 @@ declare const objectForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23677,7 +23665,7 @@ declare const objectForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23700,7 +23688,7 @@ declare const objectForm: {
         description?: string | undefined;
         visibleWhen?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23708,7 +23696,7 @@ declare const objectForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23717,7 +23705,7 @@ declare const objectForm: {
         } | undefined;
         visibleOn?: {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
@@ -23725,7 +23713,7 @@ declare const objectForm: {
             } | undefined;
         } | {
             dialect: "cel" | "cron" | "template";
-            source?: string | undefined;
+            source: string;
             ast?: unknown;
             meta?: {
                 rationale?: string | undefined;
diff --git a/packages/spec/api-surface-declarations/ui.txt b/packages/spec/api-surface-declarations/ui.txt
index 1b6f1460f7d..e119690d311 100644
--- a/packages/spec/api-surface-declarations/ui.txt
+++ b/packages/spec/api-surface-declarations/ui.txt
@@ -29,8 +29,8 @@ declare const ACTION_PARAM_BUILTIN_KEYS: readonly string[];
 declare const AIChatWindowProps: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         float: "float";
-        inline: "inline";
         sidebar: "sidebar";
+        inline: "inline";
     }>>;
     agentId: z.ZodOptional<z.ZodString>;
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3004,8 +3004,8 @@ declare const ComponentPropsMap: {
         }, z.core.$strict>>;
         allowMultiple: z.ZodDefault<z.ZodBoolean>;
         variant: z.ZodDefault<z.ZodEnum<{
-            flush: "flush";
             card: "card";
+            flush: "flush";
         }>>;
         aria: z.ZodOptional<z.ZodObject<{
             ariaLabel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
@@ -3099,8 +3099,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strict>>]>>;
         limit: z.ZodDefault<z.ZodNumber>;
@@ -3244,14 +3244,14 @@ declare const ComponentPropsMap: {
             file: "file";
             email: "email";
             system: "system";
-            approval: "approval";
             sharing: "sharing";
-            event: "event";
+            approval: "approval";
             comment: "comment";
-            note: "note";
             field_change: "field_change";
             task: "task";
+            event: "event";
             call: "call";
+            note: "note";
             record_create: "record_create";
             record_delete: "record_delete";
         }>, z.ZodString]>>>;
@@ -3302,14 +3302,14 @@ declare const ComponentPropsMap: {
                 file: "file";
                 email: "email";
                 system: "system";
-                approval: "approval";
                 sharing: "sharing";
-                event: "event";
+                approval: "approval";
                 comment: "comment";
-                note: "note";
                 field_change: "field_change";
                 task: "task";
+                event: "event";
                 call: "call";
+                note: "note";
                 record_create: "record_create";
                 record_delete: "record_delete";
             }>, z.ZodString]>>>;
@@ -3378,14 +3378,14 @@ declare const ComponentPropsMap: {
                 file: "file";
                 email: "email";
                 system: "system";
-                approval: "approval";
                 sharing: "sharing";
-                event: "event";
+                approval: "approval";
                 comment: "comment";
-                note: "note";
                 field_change: "field_change";
                 task: "task";
+                event: "event";
                 call: "call";
+                note: "note";
                 record_create: "record_create";
                 record_delete: "record_delete";
             }>, z.ZodString]>>>;
@@ -3494,8 +3494,8 @@ declare const ComponentPropsMap: {
         severity: z.ZodOptional<z.ZodEnum<{
             error: "error";
             success: "success";
-            info: "info";
             warning: "warning";
+            info: "info";
         }>>;
         title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
@@ -3564,9 +3564,9 @@ declare const ComponentPropsMap: {
                 default: "default";
                 link: "link";
                 secondary: "secondary";
-                ghost: "ghost";
-                outline: "outline";
                 destructive: "destructive";
+                outline: "outline";
+                ghost: "ghost";
             }>>;
         }, z.core.$strict>>;
         dismissible: z.ZodOptional<z.ZodBoolean>;
@@ -3593,15 +3593,15 @@ declare const ComponentPropsMap: {
             default: "default";
             link: "link";
             secondary: "secondary";
-            ghost: "ghost";
-            outline: "outline";
             destructive: "destructive";
+            outline: "outline";
+            ghost: "ghost";
         }>>;
         size: z.ZodOptional<z.ZodEnum<{
             default: "default";
-            icon: "icon";
             sm: "sm";
             lg: "lg";
+            icon: "icon";
         }>>;
     }, z.core.$strict>;
     readonly 'record:history': z.ZodObject<{
@@ -3621,8 +3621,8 @@ declare const ComponentPropsMap: {
     readonly 'ai:chat_window': z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             float: "float";
-            inline: "inline";
             sidebar: "sidebar";
+            inline: "inline";
         }>>;
         agentId: z.ZodOptional<z.ZodString>;
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3662,10 +3662,9 @@ declare const ComponentPropsMap: {
             defaultValue?: never;
         }>>]>;
         variant: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            body: "body";
-            heading: "heading";
             caption: "caption";
-            subheading: "subheading";
+            heading: "heading";
+            body: "body";
             h1: "h1";
             h2: "h2";
             h3: "h3";
@@ -3673,6 +3672,7 @@ declare const ComponentPropsMap: {
             h5: "h5";
             h6: "h6";
             overline: "overline";
+            subheading: "subheading";
         }>>>;
         align: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             left: "left";
@@ -3701,9 +3701,9 @@ declare const ComponentPropsMap: {
         object: z.ZodString;
         field: z.ZodOptional<z.ZodString>;
         aggregate: z.ZodEnum<{
-            count: "count";
             min: "min";
             max: "max";
+            count: "count";
             sum: "sum";
             avg: "avg";
         }>;
@@ -3787,8 +3787,8 @@ declare const ComponentPropsMap: {
     }, z.core.$strict>;
     readonly 'element:metadata_viewer': z.ZodObject<{
         type: z.ZodEnum<{
-            state_machine: "state_machine";
             flow: "flow";
+            state_machine: "state_machine";
             permission: "permission";
         }>;
         name: z.ZodString;
@@ -3844,8 +3844,8 @@ declare const ComponentPropsMap: {
         }>>>;
         size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             small: "small";
-            medium: "medium";
             large: "large";
+            medium: "medium";
         }>>>;
         icon: z.ZodOptional<z.ZodString>;
         iconPosition: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -3857,10 +3857,10 @@ declare const ComponentPropsMap: {
             type: z.ZodDefault<z.ZodEnum<{
                 url: "url";
                 form: "form";
-                script: "script";
+                api: "api";
                 modal: "modal";
+                script: "script";
                 flow: "flow";
-                api: "api";
             }>>;
             target: z.ZodOptional<z.ZodString>;
             params: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
@@ -3887,17 +3887,14 @@ declare const ComponentPropsMap: {
                     date: "date";
                     record: "record";
                     file: "file";
-                    tags: "tags";
                     email: "email";
-                    phone: "phone";
-                    user: "user";
-                    datetime: "datetime";
-                    location: "location";
-                    text: "text";
                     url: "url";
+                    datetime: "datetime";
                     time: "time";
                     formula: "formula";
+                    text: "text";
                     textarea: "textarea";
+                    phone: "phone";
                     password: "password";
                     secret: "secret";
                     markdown: "markdown";
@@ -3913,6 +3910,7 @@ declare const ComponentPropsMap: {
                     lookup: "lookup";
                     master_detail: "master_detail";
                     tree: "tree";
+                    user: "user";
                     image: "image";
                     avatar: "avatar";
                     video: "video";
@@ -3921,6 +3919,7 @@ declare const ComponentPropsMap: {
                     autonumber: "autonumber";
                     composite: "composite";
                     repeater: "repeater";
+                    location: "location";
                     address: "address";
                     json: "json";
                     color: "color";
@@ -3929,6 +3928,7 @@ declare const ComponentPropsMap: {
                     signature: "signature";
                     qrcode: "qrcode";
                     progress: "progress";
+                    tags: "tags";
                     vector: "vector";
                 }>>;
                 required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -4021,7 +4021,7 @@ declare const ComponentPropsMap: {
                     key?: never;
                     defaultValue?: never;
                 }) | undefined;
-                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
+                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
                 options?: {
                     label: string | (Record<string, string> & {
                         key?: never;
@@ -4082,7 +4082,7 @@ declare const ComponentPropsMap: {
                     key?: never;
                     defaultValue?: never;
                 }) | undefined;
-                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
+                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
                 options?: {
                     label: string | (Record<string, string> & {
                         key?: never;
@@ -4136,7 +4136,7 @@ declare const ComponentPropsMap: {
                 requiresFeature?: "organization" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "admin" | "phoneNumber" | "phoneNumberOtp" | undefined;
             }>>>>;
             name: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+            errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
             }, Record<string, string> & {
@@ -4149,7 +4149,7 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
-            errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
             }, Record<string, string> & {
@@ -4162,11 +4162,9 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
-            method: z.ZodOptional<z.ZodEnum<{
-                PUT: "PUT";
-                POST: "POST";
-                DELETE: "DELETE";
-                PATCH: "PATCH";
+            openIn: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                "new-tab": "new-tab";
             }>>;
             confirmText: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
@@ -4181,12 +4179,14 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
+            method: z.ZodOptional<z.ZodEnum<{
+                POST: "POST";
+                PUT: "PUT";
+                DELETE: "DELETE";
+                PATCH: "PATCH";
+            }>>;
             bodyExtra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             opensInNewTab: z.ZodOptional<z.ZodBoolean>;
-            openIn: z.ZodOptional<z.ZodEnum<{
-                self: "self";
-                "new-tab": "new-tab";
-            }>>;
             successMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
@@ -4282,8 +4282,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strip>>>;
         limit: z.ZodOptional<z.ZodNumber>;
@@ -4339,8 +4339,8 @@ declare const ComponentPropsMap: {
         inputType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             number: "number";
             email: "email";
-            text: "text";
             url: "url";
+            text: "text";
             password: "password";
             tel: "tel";
         }>>>;
@@ -4465,8 +4465,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strip>>>;
         defaultSort: z.ZodOptional<z.ZodNever>;
@@ -4505,8 +4505,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4518,8 +4518,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4582,12 +4582,12 @@ declare const ComponentPropsMap: {
         colorVariant: z.ZodOptional<z.ZodEnum<{
             default: "default";
             success: "success";
-            warning: "warning";
             danger: "danger";
             blue: "blue";
             teal: "teal";
             orange: "orange";
             purple: "purple";
+            warning: "warning";
         }>>;
         aggregate: z.ZodOptional<z.ZodUnknown>;
         filter: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -4708,8 +4708,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strip>>>;
         data: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -4721,15 +4721,15 @@ declare const ComponentPropsMap: {
         objectName: z.ZodOptional<z.ZodString>;
         recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         mode: z.ZodOptional<z.ZodEnum<{
-            create: "create";
-            edit: "edit";
             view: "view";
+            edit: "edit";
+            create: "create";
         }>>;
         formType: z.ZodOptional<z.ZodEnum<{
             split: "split";
-            simple: "simple";
-            modal: "modal";
             drawer: "drawer";
+            modal: "modal";
+            simple: "simple";
             tabbed: "tabbed";
             wizard: "wizard";
         }>>;
@@ -4881,8 +4881,8 @@ declare const ComponentPropsMap: {
         objectName: z.ZodOptional<z.ZodString>;
         recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         mode: z.ZodOptional<z.ZodEnum<{
-            create: "create";
             edit: "edit";
+            create: "create";
         }>>;
         formType: z.ZodOptional<z.ZodEnum<{
             simple: "simple";
@@ -4946,8 +4946,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4959,8 +4959,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5006,8 +5006,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strip>>>;
         map: z.ZodOptional<z.ZodObject<{
@@ -5035,8 +5035,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5048,8 +5048,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5095,8 +5095,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                desc: "desc";
                 asc: "asc";
+                desc: "desc";
             }>;
         }, z.core.$strip>>>;
         gantt: z.ZodOptional<z.ZodObject<{
@@ -5139,8 +5139,8 @@ declare const ComponentPropsMap: {
             lockField: z.ZodOptional<z.ZodString>;
             objectField: z.ZodOptional<z.ZodString>;
             summaryExtent: z.ZodOptional<z.ZodEnum<{
-                self: "self";
                 children: "children";
+                self: "self";
             }>>;
             defaultCollapsedDepth: z.ZodOptional<z.ZodNumber>;
             dependencyTypes: z.ZodOptional<z.ZodBoolean>;
@@ -5199,8 +5199,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5212,8 +5212,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    PUT: "PUT";
                     POST: "POST";
+                    PUT: "PUT";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -6495,8 +6495,8 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
     }>>>;
     size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         small: "small";
-        medium: "medium";
         large: "large";
+        medium: "medium";
     }>>>;
     icon: z.ZodOptional<z.ZodString>;
     iconPosition: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -6508,10 +6508,10 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
         type: z.ZodDefault<z.ZodEnum<{
             url: "url";
             form: "form";
-            script: "script";
+            api: "api";
             modal: "modal";
+            script: "script";
             flow: "flow";
-            api: "api";
         }>>;
         target: z.ZodOptional<z.ZodString>;
         params: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
@@ -6538,17 +6538,14 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 date: "date";
                 record: "record";
                 file: "file";
-                tags: "tags";
                 email: "email";
-                phone: "phone";
-                user: "user";
-                datetime: "datetime";
-                location: "location";
-                text: "text";
                 url: "url";
+                datetime: "datetime";
                 time: "time";
                 formula: "formula";
+                text: "text";
                 textarea: "textarea";
+                phone: "phone";
                 password: "password";
                 secret: "secret";
                 markdown: "markdown";
@@ -6564,6 +6561,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 lookup: "lookup";
                 master_detail: "master_detail";
                 tree: "tree";
+                user: "user";
                 image: "image";
                 avatar: "avatar";
                 video: "video";
@@ -6572,6 +6570,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 autonumber: "autonumber";
                 composite: "composite";
                 repeater: "repeater";
+                location: "location";
                 address: "address";
                 json: "json";
                 color: "color";
@@ -6580,6 +6579,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 signature: "signature";
                 qrcode: "qrcode";
                 progress: "progress";
+                tags: "tags";
                 vector: "vector";
             }>>;
             required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -6672,7 +6672,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 key?: never;
                 defaultValue?: never;
             }) | undefined;
-            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
+            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
             options?: {
                 label: string | (Record<string, string> & {
                     key?: never;
@@ -6733,7 +6733,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 key?: never;
                 defaultValue?: never;
             }) | undefined;
-            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
+            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
             options?: {
                 label: string | (Record<string, string> & {
                     key?: never;
@@ -6787,7 +6787,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             requiresFeature?: "organization" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "admin" | "phoneNumber" | "phoneNumberOtp" | undefined;
         }>>>>;
         name: z.ZodOptional<z.ZodString>;
-        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+        errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
         }, Record<string, string> & {
@@ -6800,7 +6800,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
-        errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
         }, Record<string, string> & {
@@ -6813,11 +6813,9 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
-        method: z.ZodOptional<z.ZodEnum<{
-            PUT: "PUT";
-            POST: "POST";
-            DELETE: "DELETE";
-            PATCH: "PATCH";
+        openIn: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            "new-tab": "new-tab";
         }>>;
         confirmText: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
@@ -6832,12 +6830,14 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
+        method: z.ZodOptional<z.ZodEnum<{
+            POST: "POST";
+            PUT: "PUT";
+            DELETE: "DELETE";
+            PATCH: "PATCH";
+        }>>;
         bodyExtra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         opensInNewTab: z.ZodOptional<z.ZodBoolean>;
-        openIn: z.ZodOptional<z.ZodEnum<{
-            self: "self";
-            "new-tab": "new-tab";
-        }>>;
         successMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
@@ -6970,8 +6970,8 @@ declare const ElementImagePropsSchema: z.ZodObject<{
 // ── ElementMetadataViewerPropsSchema (const) ──
 declare const ElementMetadataViewerPropsSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        state_machine: "state_machine";
         flow: "flow";
+        state_machine: "state_machine";
         permission: "permission";
     }>;
     name: z.ZodString;
@@ -7015,9 +7015,9 @@ declare const ElementNumberPropsSchema: z.ZodObject<{
     object: z.ZodString;
     field: z.ZodOptional<z.ZodString>;
     aggregate: z.ZodEnum<{
-        count: "count";
         min: "min";
         max: "max";
+        count: "count";
         sum: "sum";
         avg: "avg";
     }>;
@@ -7126,8 +7126,8 @@ declare const ElementRecordPickerPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strip>>>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -7185,8 +7185,8 @@ declare const ElementTextInputPropsSchema: z.ZodObject<{
     inputType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         number: "number";
         email: "email";
-        text: "text";
         url: "url";
+        text: "text";
         password: "password";
         tel: "tel";
     }>>>;
@@ -7268,10 +7268,9 @@ declare const ElementTextPropsSchema: z.ZodObject<{
         defaultValue?: never;
     }>>]>;
     variant: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        body: "body";
-        heading: "heading";
         caption: "caption";
-        subheading: "subheading";
+        heading: "heading";
+        body: "body";
         h1: "h1";
         h2: "h2";
         h3: "h3";
@@ -7279,6 +7278,7 @@ declare const ElementTextPropsSchema: z.ZodObject<{
         h5: "h5";
         h6: "h6";
         overline: "overline";
+        subheading: "subheading";
     }>>>;
     align: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         left: "left";
@@ -7359,10 +7359,10 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
     field: z.ZodObject<{
         _lock: z.ZodOptional<z.ZodEnum<{
-            full: "full";
             none: "none";
             "no-overlay": "no-overlay";
             "no-delete": "no-delete";
+            full: "full";
         }>>;
         _lockReason: z.ZodOptional<z.ZodString>;
         _lockSource: z.ZodOptional<z.ZodEnum<{
@@ -7387,17 +7387,14 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             date: "date";
             record: "record";
             file: "file";
-            tags: "tags";
             email: "email";
-            phone: "phone";
-            user: "user";
-            datetime: "datetime";
-            location: "location";
-            text: "text";
             url: "url";
+            datetime: "datetime";
             time: "time";
             formula: "formula";
+            text: "text";
             textarea: "textarea";
+            phone: "phone";
             password: "password";
             secret: "secret";
             markdown: "markdown";
@@ -7413,6 +7410,7 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             lookup: "lookup";
             master_detail: "master_detail";
             tree: "tree";
+            user: "user";
             image: "image";
             avatar: "avatar";
             video: "video";
@@ -7421,6 +7419,7 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             autonumber: "autonumber";
             composite: "composite";
             repeater: "repeater";
+            location: "location";
             address: "address";
             json: "json";
             color: "color";
@@ -7429,6 +7428,7 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             signature: "signature";
             qrcode: "qrcode";
             progress: "progress";
+            tags: "tags";
             vector: "vector";
         }>;
         description: z.ZodOptional<z.ZodString>;
@@ -7504,8 +7504,8 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
                 date: "date";
                 file: "file";
                 datetime: "datetime";
-                text: "text";
                 time: "time";
+                text: "text";
                 currency: "currency";
                 select: "select";
                 lookup: "lookup";
@@ -7636,9 +7636,9 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             object: z.ZodString;
             field: z.ZodString;
             function: z.ZodEnum<{
-                count: "count";
                 min: "min";
                 max: "max";
+                count: "count";
                 sum: "sum";
                 avg: "avg";
             }>;
@@ -7728,8 +7728,8 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
         readonly: z.ZodDefault<z.ZodBoolean>;
         requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         maskingRule: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            name: "name";
             email: "email";
+            name: "name";
             phone: "phone";
             id_card: "id_card";
             bank_account: "bank_account";
@@ -10615,8 +10615,8 @@ type NotificationSeverity = z.input<typeof NotificationSeveritySchema>;
 declare const NotificationSeveritySchema: z.ZodEnum<{
     error: "error";
     success: "success";
-    info: "info";
     warning: "warning";
+    info: "info";
 }>;
 
 // ── NotificationType (type) ──
@@ -10624,11 +10624,11 @@ type NotificationType = z.input<typeof NotificationTypeSchema>;
 
 // ── NotificationTypeSchema (const) ──
 declare const NotificationTypeSchema: z.ZodEnum<{
-    alert: "alert";
-    toast: "toast";
     inline: "inline";
+    toast: "toast";
     banner: "banner";
     snackbar: "snackbar";
+    alert: "alert";
 }>;
 
 // ── ObjectCalendarProps (type) ──
@@ -10675,8 +10675,8 @@ declare const ObjectCalendarPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strip>>>;
     data: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -10693,15 +10693,15 @@ declare const ObjectFormPropsSchema: z.ZodObject<{
     objectName: z.ZodOptional<z.ZodString>;
     recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        create: "create";
-        edit: "edit";
         view: "view";
+        edit: "edit";
+        create: "create";
     }>>;
     formType: z.ZodOptional<z.ZodEnum<{
         split: "split";
-        simple: "simple";
-        modal: "modal";
         drawer: "drawer";
+        modal: "modal";
+        simple: "simple";
         tabbed: "tabbed";
         wizard: "wizard";
     }>>;
@@ -10868,8 +10868,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -10881,8 +10881,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -10928,8 +10928,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strip>>>;
     gantt: z.ZodOptional<z.ZodObject<{
@@ -10972,8 +10972,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
         lockField: z.ZodOptional<z.ZodString>;
         objectField: z.ZodOptional<z.ZodString>;
         summaryExtent: z.ZodOptional<z.ZodEnum<{
-            self: "self";
             children: "children";
+            self: "self";
         }>>;
         defaultCollapsedDepth: z.ZodOptional<z.ZodNumber>;
         dependencyTypes: z.ZodOptional<z.ZodBoolean>;
@@ -11089,8 +11089,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strip>>>;
     defaultSort: z.ZodOptional<z.ZodNever>;
@@ -11129,8 +11129,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11142,8 +11142,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11963,8 +11963,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11976,8 +11976,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12023,8 +12023,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strip>>>;
     map: z.ZodOptional<z.ZodObject<{
@@ -12050,8 +12050,8 @@ declare const ObjectMasterDetailFormPropsSchema: z.ZodObject<{
     objectName: z.ZodOptional<z.ZodString>;
     recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        create: "create";
         edit: "edit";
+        create: "create";
     }>>;
     formType: z.ZodOptional<z.ZodEnum<{
         simple: "simple";
@@ -12157,12 +12157,12 @@ declare const ObjectMetricPropsSchema: z.ZodObject<{
     colorVariant: z.ZodOptional<z.ZodEnum<{
         default: "default";
         success: "success";
-        warning: "warning";
         danger: "danger";
         blue: "blue";
         teal: "teal";
         orange: "orange";
         purple: "purple";
+        warning: "warning";
     }>>;
     aggregate: z.ZodOptional<z.ZodUnknown>;
     filter: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -12291,8 +12291,8 @@ declare const ObjectTreePropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12304,8 +12304,8 @@ declare const ObjectTreePropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                PUT: "PUT";
                 POST: "POST";
+                PUT: "PUT";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12435,8 +12435,8 @@ declare const PageAccordionProps: z.ZodObject<{
     }, z.core.$strict>>;
     allowMultiple: z.ZodDefault<z.ZodBoolean>;
     variant: z.ZodDefault<z.ZodEnum<{
-        flush: "flush";
         card: "card";
+        flush: "flush";
     }>>;
     aria: z.ZodOptional<z.ZodObject<{
         ariaLabel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
@@ -18459,14 +18459,14 @@ declare const RecordActivityProps: z.ZodObject<{
         file: "file";
         email: "email";
         system: "system";
-        approval: "approval";
         sharing: "sharing";
-        event: "event";
+        approval: "approval";
         comment: "comment";
-        note: "note";
         field_change: "field_change";
         task: "task";
+        event: "event";
         call: "call";
+        note: "note";
         record_create: "record_create";
         record_delete: "record_delete";
     }>, z.ZodString]>>>;
@@ -18527,9 +18527,9 @@ declare const RecordAlertActionSchema: z.ZodObject<{
         default: "default";
         link: "link";
         secondary: "secondary";
-        ghost: "ghost";
-        outline: "outline";
         destructive: "destructive";
+        outline: "outline";
+        ghost: "ghost";
     }>>;
 }, z.core.$strict>;
 
@@ -18538,8 +18538,8 @@ declare const RecordAlertProps: z.ZodObject<{
     severity: z.ZodOptional<z.ZodEnum<{
         error: "error";
         success: "success";
-        info: "info";
         warning: "warning";
+        info: "info";
     }>>;
     title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
         key?: never;
@@ -18608,9 +18608,9 @@ declare const RecordAlertProps: z.ZodObject<{
             default: "default";
             link: "link";
             secondary: "secondary";
-            ghost: "ghost";
-            outline: "outline";
             destructive: "destructive";
+            outline: "outline";
+            ghost: "ghost";
         }>>;
     }, z.core.$strict>>;
     dismissible: z.ZodOptional<z.ZodBoolean>;
@@ -18638,14 +18638,14 @@ declare const RecordChatterProps: z.ZodObject<{
             file: "file";
             email: "email";
             system: "system";
-            approval: "approval";
             sharing: "sharing";
-            event: "event";
+            approval: "approval";
             comment: "comment";
-            note: "note";
             field_change: "field_change";
             task: "task";
+            event: "event";
             call: "call";
+            note: "note";
             record_create: "record_create";
             record_delete: "record_delete";
         }>, z.ZodString]>>>;
@@ -18885,15 +18885,15 @@ declare const RecordQuickActionsProps: z.ZodObject<{
         default: "default";
         link: "link";
         secondary: "secondary";
-        ghost: "ghost";
-        outline: "outline";
         destructive: "destructive";
+        outline: "outline";
+        ghost: "ghost";
     }>>;
     size: z.ZodOptional<z.ZodEnum<{
         default: "default";
-        icon: "icon";
         sm: "sm";
         lg: "lg";
+        icon: "icon";
     }>>;
 }, z.core.$strict>;
 
@@ -18924,8 +18924,8 @@ declare const RecordRelatedListProps: z.ZodObject<{
     sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            desc: "desc";
             asc: "asc";
+            desc: "desc";
         }>;
     }, z.core.$strict>>]>>;
     limit: z.ZodDefault<z.ZodNumber>;
@@ -27034,7 +27034,7 @@ declare const WidgetColorVariantSchema: z.ZodEnum<{
 
 // ── actionForm (const) ──
 declare const actionForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27056,14 +27056,14 @@ declare const actionForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27234,7 +27234,7 @@ declare const actionForm: {
 
 // ── appForm (const) ──
 declare const appForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27256,14 +27256,14 @@ declare const appForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27491,7 +27491,7 @@ declare function compileListViewGroupRowsQuery(view: Pick<ListViewGroupQuerySour
 
 // ── dashboardForm (const) ──
 declare const dashboardForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27513,14 +27513,14 @@ declare const dashboardForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27691,7 +27691,7 @@ declare const dashboardForm: {
 
 // ── datasetForm (const) ──
 declare const datasetForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27713,14 +27713,14 @@ declare const datasetForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27970,7 +27970,7 @@ declare function objectNavTargetExclusivity(item: {
 
 // ── pageForm (const) ──
 declare const pageForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27992,14 +27992,14 @@ declare const pageForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -28176,7 +28176,7 @@ declare function reactBlockTagFor(schemaType: string): string;
 
 // ── reportForm (const) ──
 declare const reportForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -28198,14 +28198,14 @@ declare const reportForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -28396,7 +28396,7 @@ declare function validateActionParams(resolved: ResolvedActionParam[], bag: Reco
 
 // ── viewForm (const) ──
 declare const viewForm: {
-    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
+    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -28418,14 +28418,14 @@ declare const viewForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
+            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;

From e989c90d70bb87ff38bd3bf339439ff897ca8508 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 16:31:29 +0000
Subject: [PATCH 10/11] chore(spec): regenerate ui and automation shards from a
 FORCED build
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous regeneration read a dist that turbo served from the shared cache,
which every worktree on this container replays, so the committed bytes were not
what this tree builds. Two independent `build --force` runs of this exact tree
agree with each other and disagree with what was committed; these are the
forced-build bytes.

Both shards move order-only against the merge base — identical token multiset,
identical line count, nothing added, removed or renamed. `data.txt` is
unchanged by this commit and still carries this branch's +11 exported names.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 .../api-surface-declarations/automation.txt   |  48 +--
 packages/spec/api-surface-declarations/ui.txt | 330 +++++++++---------
 2 files changed, 189 insertions(+), 189 deletions(-)

diff --git a/packages/spec/api-surface-declarations/automation.txt b/packages/spec/api-surface-declarations/automation.txt
index 834d58c8d10..dcb0b9bfb53 100644
--- a/packages/spec/api-surface-declarations/automation.txt
+++ b/packages/spec/api-surface-declarations/automation.txt
@@ -139,8 +139,8 @@ declare const ActionCategorySchema: z.ZodEnum<{
     io: "io";
     control: "control";
     data: "data";
-    logic: "logic";
     human: "human";
+    logic: "logic";
 }>;
 
 // ── ActionDescriptor (type) ──
@@ -161,8 +161,8 @@ declare const ActionDescriptorSchema: z.ZodObject<{
         io: "io";
         control: "control";
         data: "data";
-        logic: "logic";
         human: "human";
+        logic: "logic";
     }>>;
     paradigms: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         flow: "flow";
@@ -188,8 +188,8 @@ declare const ActionDescriptorSchema: z.ZodObject<{
         reserved: "reserved";
     }>>;
     source: z.ZodDefault<z.ZodEnum<{
-        builtin: "builtin";
         plugin: "plugin";
+        builtin: "builtin";
     }>>;
     deprecated: z.ZodDefault<z.ZodBoolean>;
     aliasOf: z.ZodOptional<z.ZodString>;
@@ -805,13 +805,13 @@ declare const ExecutionLogSchema: z.ZodObject<{
     flowName: z.ZodString;
     flowVersion: z.ZodOptional<z.ZodNumber>;
     status: z.ZodEnum<{
-        completed: "completed";
+        failed: "failed";
         refused: "refused";
         pending: "pending";
+        completed: "completed";
         running: "running";
-        paused: "paused";
-        failed: "failed";
         cancelled: "cancelled";
+        paused: "paused";
         timed_out: "timed_out";
         retrying: "retrying";
     }>;
@@ -829,8 +829,8 @@ declare const ExecutionLogSchema: z.ZodObject<{
         nodeLabel: z.ZodOptional<z.ZodString>;
         status: z.ZodEnum<{
             success: "success";
-            failure: "failure";
             skipped: "skipped";
+            failure: "failure";
         }>;
         startedAt: z.ZodString;
         completedAt: z.ZodOptional<z.ZodString>;
@@ -871,8 +871,8 @@ declare const ExecutionLogSchema: z.ZodObject<{
             nodeLabel: z.ZodOptional<z.ZodString>;
             status: z.ZodEnum<{
                 success: "success";
-                failure: "failure";
                 skipped: "skipped";
+                failure: "failure";
             }>;
             runs: z.ZodNumber;
             failures: z.ZodNumber;
@@ -903,13 +903,13 @@ declare const ExecutionLogSchema: z.ZodObject<{
 
 // ── ExecutionStatus (const) ──
 declare const ExecutionStatus: z.ZodEnum<{
-    completed: "completed";
+    failed: "failed";
     refused: "refused";
     pending: "pending";
+    completed: "completed";
     running: "running";
-    paused: "paused";
-    failed: "failed";
     cancelled: "cancelled";
+    paused: "paused";
     timed_out: "timed_out";
     retrying: "retrying";
 }>;
@@ -930,8 +930,8 @@ declare const ExecutionStepLogSchema: z.ZodObject<{
     nodeLabel: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
         success: "success";
-        failure: "failure";
         skipped: "skipped";
+        failure: "failure";
     }>;
     startedAt: z.ZodString;
     completedAt: z.ZodOptional<z.ZodString>;
@@ -1585,8 +1585,8 @@ declare const FlowRunNodeSummarySchema: z.ZodObject<{
     nodeLabel: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
         success: "success";
-        failure: "failure";
         skipped: "skipped";
+        failure: "failure";
     }>;
     runs: z.ZodNumber;
     failures: z.ZodNumber;
@@ -1615,8 +1615,8 @@ declare const FlowRunSummarySchema: z.ZodObject<{
         nodeLabel: z.ZodOptional<z.ZodString>;
         status: z.ZodEnum<{
             success: "success";
-            failure: "failure";
             skipped: "skipped";
+            failure: "failure";
         }>;
         runs: z.ZodNumber;
         failures: z.ZodNumber;
@@ -2909,20 +2909,20 @@ declare const ScheduleStateSchema: z.ZodObject<{
     status: z.ZodDefault<z.ZodEnum<{
         disabled: "disabled";
         active: "active";
-        paused: "paused";
         expired: "expired";
+        paused: "paused";
     }>>;
     nextRunAt: z.ZodOptional<z.ZodString>;
     lastRunAt: z.ZodOptional<z.ZodString>;
     lastExecutionId: z.ZodOptional<z.ZodString>;
     lastRunStatus: z.ZodOptional<z.ZodEnum<{
-        completed: "completed";
+        failed: "failed";
         refused: "refused";
         pending: "pending";
+        completed: "completed";
         running: "running";
-        paused: "paused";
-        failed: "failed";
         cancelled: "cancelled";
+        paused: "paused";
         timed_out: "timed_out";
         retrying: "retrying";
     }>>;
@@ -3508,10 +3508,10 @@ type WaitEventType = z.input<typeof WaitEventTypeSchema>;
 // ── WaitEventTypeSchema (const) ──
 declare const WaitEventTypeSchema: z.ZodEnum<{
     condition: "condition";
+    manual: "manual";
+    webhook: "webhook";
     timer: "timer";
     signal: "signal";
-    webhook: "webhook";
-    manual: "manual";
 }>;
 
 // ── WaitExecutorConfig (type) ──
@@ -3525,8 +3525,8 @@ declare const WaitExecutorConfigSchema: z.ZodObject<{
     defaultTimeoutMs: z.ZodDefault<z.ZodNumber>;
     defaultTimeoutBehavior: z.ZodDefault<z.ZodEnum<{
         continue: "continue";
-        fallback: "fallback";
         fail: "fail";
+        fallback: "fallback";
     }>>;
     conditionPollIntervalMs: z.ZodDefault<z.ZodNumber>;
     conditionMaxPolls: z.ZodDefault<z.ZodNumber>;
@@ -3545,10 +3545,10 @@ declare const WaitResumePayloadSchema: z.ZodObject<{
     nodeId: z.ZodString;
     eventType: z.ZodEnum<{
         condition: "condition";
+        manual: "manual";
+        webhook: "webhook";
         timer: "timer";
         signal: "signal";
-        webhook: "webhook";
-        manual: "manual";
     }>;
     signalName: z.ZodOptional<z.ZodString>;
     webhookPayload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3563,8 +3563,8 @@ type WaitTimeoutBehavior = z.input<typeof WaitTimeoutBehaviorSchema>;
 // ── WaitTimeoutBehaviorSchema (const) ──
 declare const WaitTimeoutBehaviorSchema: z.ZodEnum<{
     continue: "continue";
-    fallback: "fallback";
     fail: "fail";
+    fallback: "fallback";
 }>;
 
 // ── Webhook (type) ──
diff --git a/packages/spec/api-surface-declarations/ui.txt b/packages/spec/api-surface-declarations/ui.txt
index e119690d311..1b6f1460f7d 100644
--- a/packages/spec/api-surface-declarations/ui.txt
+++ b/packages/spec/api-surface-declarations/ui.txt
@@ -29,8 +29,8 @@ declare const ACTION_PARAM_BUILTIN_KEYS: readonly string[];
 declare const AIChatWindowProps: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         float: "float";
-        sidebar: "sidebar";
         inline: "inline";
+        sidebar: "sidebar";
     }>>;
     agentId: z.ZodOptional<z.ZodString>;
     context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3004,8 +3004,8 @@ declare const ComponentPropsMap: {
         }, z.core.$strict>>;
         allowMultiple: z.ZodDefault<z.ZodBoolean>;
         variant: z.ZodDefault<z.ZodEnum<{
-            card: "card";
             flush: "flush";
+            card: "card";
         }>>;
         aria: z.ZodOptional<z.ZodObject<{
             ariaLabel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
@@ -3099,8 +3099,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strict>>]>>;
         limit: z.ZodDefault<z.ZodNumber>;
@@ -3244,14 +3244,14 @@ declare const ComponentPropsMap: {
             file: "file";
             email: "email";
             system: "system";
-            sharing: "sharing";
             approval: "approval";
+            sharing: "sharing";
+            event: "event";
             comment: "comment";
+            note: "note";
             field_change: "field_change";
             task: "task";
-            event: "event";
             call: "call";
-            note: "note";
             record_create: "record_create";
             record_delete: "record_delete";
         }>, z.ZodString]>>>;
@@ -3302,14 +3302,14 @@ declare const ComponentPropsMap: {
                 file: "file";
                 email: "email";
                 system: "system";
-                sharing: "sharing";
                 approval: "approval";
+                sharing: "sharing";
+                event: "event";
                 comment: "comment";
+                note: "note";
                 field_change: "field_change";
                 task: "task";
-                event: "event";
                 call: "call";
-                note: "note";
                 record_create: "record_create";
                 record_delete: "record_delete";
             }>, z.ZodString]>>>;
@@ -3378,14 +3378,14 @@ declare const ComponentPropsMap: {
                 file: "file";
                 email: "email";
                 system: "system";
-                sharing: "sharing";
                 approval: "approval";
+                sharing: "sharing";
+                event: "event";
                 comment: "comment";
+                note: "note";
                 field_change: "field_change";
                 task: "task";
-                event: "event";
                 call: "call";
-                note: "note";
                 record_create: "record_create";
                 record_delete: "record_delete";
             }>, z.ZodString]>>>;
@@ -3494,8 +3494,8 @@ declare const ComponentPropsMap: {
         severity: z.ZodOptional<z.ZodEnum<{
             error: "error";
             success: "success";
-            warning: "warning";
             info: "info";
+            warning: "warning";
         }>>;
         title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
@@ -3564,9 +3564,9 @@ declare const ComponentPropsMap: {
                 default: "default";
                 link: "link";
                 secondary: "secondary";
-                destructive: "destructive";
-                outline: "outline";
                 ghost: "ghost";
+                outline: "outline";
+                destructive: "destructive";
             }>>;
         }, z.core.$strict>>;
         dismissible: z.ZodOptional<z.ZodBoolean>;
@@ -3593,15 +3593,15 @@ declare const ComponentPropsMap: {
             default: "default";
             link: "link";
             secondary: "secondary";
-            destructive: "destructive";
-            outline: "outline";
             ghost: "ghost";
+            outline: "outline";
+            destructive: "destructive";
         }>>;
         size: z.ZodOptional<z.ZodEnum<{
             default: "default";
+            icon: "icon";
             sm: "sm";
             lg: "lg";
-            icon: "icon";
         }>>;
     }, z.core.$strict>;
     readonly 'record:history': z.ZodObject<{
@@ -3621,8 +3621,8 @@ declare const ComponentPropsMap: {
     readonly 'ai:chat_window': z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             float: "float";
-            sidebar: "sidebar";
             inline: "inline";
+            sidebar: "sidebar";
         }>>;
         agentId: z.ZodOptional<z.ZodString>;
         context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -3662,9 +3662,10 @@ declare const ComponentPropsMap: {
             defaultValue?: never;
         }>>]>;
         variant: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-            caption: "caption";
-            heading: "heading";
             body: "body";
+            heading: "heading";
+            caption: "caption";
+            subheading: "subheading";
             h1: "h1";
             h2: "h2";
             h3: "h3";
@@ -3672,7 +3673,6 @@ declare const ComponentPropsMap: {
             h5: "h5";
             h6: "h6";
             overline: "overline";
-            subheading: "subheading";
         }>>>;
         align: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             left: "left";
@@ -3701,9 +3701,9 @@ declare const ComponentPropsMap: {
         object: z.ZodString;
         field: z.ZodOptional<z.ZodString>;
         aggregate: z.ZodEnum<{
+            count: "count";
             min: "min";
             max: "max";
-            count: "count";
             sum: "sum";
             avg: "avg";
         }>;
@@ -3787,8 +3787,8 @@ declare const ComponentPropsMap: {
     }, z.core.$strict>;
     readonly 'element:metadata_viewer': z.ZodObject<{
         type: z.ZodEnum<{
-            flow: "flow";
             state_machine: "state_machine";
+            flow: "flow";
             permission: "permission";
         }>;
         name: z.ZodString;
@@ -3844,8 +3844,8 @@ declare const ComponentPropsMap: {
         }>>>;
         size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             small: "small";
-            large: "large";
             medium: "medium";
+            large: "large";
         }>>>;
         icon: z.ZodOptional<z.ZodString>;
         iconPosition: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -3857,10 +3857,10 @@ declare const ComponentPropsMap: {
             type: z.ZodDefault<z.ZodEnum<{
                 url: "url";
                 form: "form";
-                api: "api";
-                modal: "modal";
                 script: "script";
+                modal: "modal";
                 flow: "flow";
+                api: "api";
             }>>;
             target: z.ZodOptional<z.ZodString>;
             params: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
@@ -3887,14 +3887,17 @@ declare const ComponentPropsMap: {
                     date: "date";
                     record: "record";
                     file: "file";
+                    tags: "tags";
                     email: "email";
-                    url: "url";
+                    phone: "phone";
+                    user: "user";
                     datetime: "datetime";
+                    location: "location";
+                    text: "text";
+                    url: "url";
                     time: "time";
                     formula: "formula";
-                    text: "text";
                     textarea: "textarea";
-                    phone: "phone";
                     password: "password";
                     secret: "secret";
                     markdown: "markdown";
@@ -3910,7 +3913,6 @@ declare const ComponentPropsMap: {
                     lookup: "lookup";
                     master_detail: "master_detail";
                     tree: "tree";
-                    user: "user";
                     image: "image";
                     avatar: "avatar";
                     video: "video";
@@ -3919,7 +3921,6 @@ declare const ComponentPropsMap: {
                     autonumber: "autonumber";
                     composite: "composite";
                     repeater: "repeater";
-                    location: "location";
                     address: "address";
                     json: "json";
                     color: "color";
@@ -3928,7 +3929,6 @@ declare const ComponentPropsMap: {
                     signature: "signature";
                     qrcode: "qrcode";
                     progress: "progress";
-                    tags: "tags";
                     vector: "vector";
                 }>>;
                 required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -4021,7 +4021,7 @@ declare const ComponentPropsMap: {
                     key?: never;
                     defaultValue?: never;
                 }) | undefined;
-                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
+                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
                 options?: {
                     label: string | (Record<string, string> & {
                         key?: never;
@@ -4082,7 +4082,7 @@ declare const ComponentPropsMap: {
                     key?: never;
                     defaultValue?: never;
                 }) | undefined;
-                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
+                type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
                 options?: {
                     label: string | (Record<string, string> & {
                         key?: never;
@@ -4136,7 +4136,7 @@ declare const ComponentPropsMap: {
                 requiresFeature?: "organization" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "admin" | "phoneNumber" | "phoneNumberOtp" | undefined;
             }>>>>;
             name: z.ZodOptional<z.ZodString>;
-            errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
             }, Record<string, string> & {
@@ -4149,7 +4149,7 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
-            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+            errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
             }, Record<string, string> & {
@@ -4162,9 +4162,11 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
-            openIn: z.ZodOptional<z.ZodEnum<{
-                self: "self";
-                "new-tab": "new-tab";
+            method: z.ZodOptional<z.ZodEnum<{
+                PUT: "PUT";
+                POST: "POST";
+                DELETE: "DELETE";
+                PATCH: "PATCH";
             }>>;
             confirmText: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
@@ -4179,14 +4181,12 @@ declare const ComponentPropsMap: {
                 key?: never;
                 defaultValue?: never;
             }>>]>>;
-            method: z.ZodOptional<z.ZodEnum<{
-                POST: "POST";
-                PUT: "PUT";
-                DELETE: "DELETE";
-                PATCH: "PATCH";
-            }>>;
             bodyExtra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             opensInNewTab: z.ZodOptional<z.ZodBoolean>;
+            openIn: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                "new-tab": "new-tab";
+            }>>;
             successMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
                 key?: never;
                 defaultValue?: never;
@@ -4282,8 +4282,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strip>>>;
         limit: z.ZodOptional<z.ZodNumber>;
@@ -4339,8 +4339,8 @@ declare const ComponentPropsMap: {
         inputType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
             number: "number";
             email: "email";
-            url: "url";
             text: "text";
+            url: "url";
             password: "password";
             tel: "tel";
         }>>>;
@@ -4465,8 +4465,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strip>>>;
         defaultSort: z.ZodOptional<z.ZodNever>;
@@ -4505,8 +4505,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4518,8 +4518,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4582,12 +4582,12 @@ declare const ComponentPropsMap: {
         colorVariant: z.ZodOptional<z.ZodEnum<{
             default: "default";
             success: "success";
+            warning: "warning";
             danger: "danger";
             blue: "blue";
             teal: "teal";
             orange: "orange";
             purple: "purple";
-            warning: "warning";
         }>>;
         aggregate: z.ZodOptional<z.ZodUnknown>;
         filter: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -4708,8 +4708,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strip>>>;
         data: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -4721,15 +4721,15 @@ declare const ComponentPropsMap: {
         objectName: z.ZodOptional<z.ZodString>;
         recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         mode: z.ZodOptional<z.ZodEnum<{
-            view: "view";
-            edit: "edit";
             create: "create";
+            edit: "edit";
+            view: "view";
         }>>;
         formType: z.ZodOptional<z.ZodEnum<{
             split: "split";
-            drawer: "drawer";
-            modal: "modal";
             simple: "simple";
+            modal: "modal";
+            drawer: "drawer";
             tabbed: "tabbed";
             wizard: "wizard";
         }>>;
@@ -4881,8 +4881,8 @@ declare const ComponentPropsMap: {
         objectName: z.ZodOptional<z.ZodString>;
         recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
         mode: z.ZodOptional<z.ZodEnum<{
-            edit: "edit";
             create: "create";
+            edit: "edit";
         }>>;
         formType: z.ZodOptional<z.ZodEnum<{
             simple: "simple";
@@ -4946,8 +4946,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -4959,8 +4959,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5006,8 +5006,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strip>>>;
         map: z.ZodOptional<z.ZodObject<{
@@ -5035,8 +5035,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5048,8 +5048,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5095,8 +5095,8 @@ declare const ComponentPropsMap: {
         sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
             field: z.ZodString;
             order: z.ZodEnum<{
-                asc: "asc";
                 desc: "desc";
+                asc: "asc";
             }>;
         }, z.core.$strip>>>;
         gantt: z.ZodOptional<z.ZodObject<{
@@ -5139,8 +5139,8 @@ declare const ComponentPropsMap: {
             lockField: z.ZodOptional<z.ZodString>;
             objectField: z.ZodOptional<z.ZodString>;
             summaryExtent: z.ZodOptional<z.ZodEnum<{
-                children: "children";
                 self: "self";
+                children: "children";
             }>>;
             defaultCollapsedDepth: z.ZodOptional<z.ZodNumber>;
             dependencyTypes: z.ZodOptional<z.ZodBoolean>;
@@ -5199,8 +5199,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -5212,8 +5212,8 @@ declare const ComponentPropsMap: {
                 url: z.ZodString;
                 method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                     GET: "GET";
-                    POST: "POST";
                     PUT: "PUT";
+                    POST: "POST";
                     DELETE: "DELETE";
                     PATCH: "PATCH";
                 }>>>;
@@ -6495,8 +6495,8 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
     }>>>;
     size: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         small: "small";
-        large: "large";
         medium: "medium";
+        large: "large";
     }>>>;
     icon: z.ZodOptional<z.ZodString>;
     iconPosition: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -6508,10 +6508,10 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
         type: z.ZodDefault<z.ZodEnum<{
             url: "url";
             form: "form";
-            api: "api";
-            modal: "modal";
             script: "script";
+            modal: "modal";
             flow: "flow";
+            api: "api";
         }>>;
         target: z.ZodOptional<z.ZodString>;
         params: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
@@ -6538,14 +6538,17 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 date: "date";
                 record: "record";
                 file: "file";
+                tags: "tags";
                 email: "email";
-                url: "url";
+                phone: "phone";
+                user: "user";
                 datetime: "datetime";
+                location: "location";
+                text: "text";
+                url: "url";
                 time: "time";
                 formula: "formula";
-                text: "text";
                 textarea: "textarea";
-                phone: "phone";
                 password: "password";
                 secret: "secret";
                 markdown: "markdown";
@@ -6561,7 +6564,6 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 lookup: "lookup";
                 master_detail: "master_detail";
                 tree: "tree";
-                user: "user";
                 image: "image";
                 avatar: "avatar";
                 video: "video";
@@ -6570,7 +6572,6 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 autonumber: "autonumber";
                 composite: "composite";
                 repeater: "repeater";
-                location: "location";
                 address: "address";
                 json: "json";
                 color: "color";
@@ -6579,7 +6580,6 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 signature: "signature";
                 qrcode: "qrcode";
                 progress: "progress";
-                tags: "tags";
                 vector: "vector";
             }>>;
             required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -6672,7 +6672,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 key?: never;
                 defaultValue?: never;
             }) | undefined;
-            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
+            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
             options?: {
                 label: string | (Record<string, string> & {
                     key?: never;
@@ -6733,7 +6733,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
                 key?: never;
                 defaultValue?: never;
             }) | undefined;
-            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "email" | "url" | "datetime" | "time" | "formula" | "text" | "textarea" | "phone" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "user" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "location" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "tags" | "vector" | undefined;
+            type?: "number" | "boolean" | "code" | "date" | "record" | "file" | "tags" | "email" | "phone" | "user" | "datetime" | "location" | "text" | "url" | "time" | "formula" | "textarea" | "password" | "secret" | "markdown" | "html" | "richtext" | "currency" | "percent" | "toggle" | "select" | "multiselect" | "radio" | "checkboxes" | "lookup" | "master_detail" | "tree" | "image" | "avatar" | "video" | "audio" | "summary" | "autonumber" | "composite" | "repeater" | "address" | "json" | "color" | "rating" | "slider" | "signature" | "qrcode" | "progress" | "vector" | undefined;
             options?: {
                 label: string | (Record<string, string> & {
                     key?: never;
@@ -6787,7 +6787,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             requiresFeature?: "organization" | "twoFactor" | "multiOrgEnabled" | "degradedTenancy" | "oidcProvider" | "sso" | "ssoEnforced" | "deviceAuthorization" | "admin" | "phoneNumber" | "phoneNumberOtp" | undefined;
         }>>>>;
         name: z.ZodOptional<z.ZodString>;
-        errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
         }, Record<string, string> & {
@@ -6800,7 +6800,7 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
-        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
+        errorMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
         }, Record<string, string> & {
@@ -6813,9 +6813,11 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
-        openIn: z.ZodOptional<z.ZodEnum<{
-            self: "self";
-            "new-tab": "new-tab";
+        method: z.ZodOptional<z.ZodEnum<{
+            PUT: "PUT";
+            POST: "POST";
+            DELETE: "DELETE";
+            PATCH: "PATCH";
         }>>;
         confirmText: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
@@ -6830,14 +6832,12 @@ declare const ElementButtonPropsSchema: z.ZodObject<{
             key?: never;
             defaultValue?: never;
         }>>]>>;
-        method: z.ZodOptional<z.ZodEnum<{
-            POST: "POST";
-            PUT: "PUT";
-            DELETE: "DELETE";
-            PATCH: "PATCH";
-        }>>;
         bodyExtra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         opensInNewTab: z.ZodOptional<z.ZodBoolean>;
+        openIn: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            "new-tab": "new-tab";
+        }>>;
         successMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
             key?: never;
             defaultValue?: never;
@@ -6970,8 +6970,8 @@ declare const ElementImagePropsSchema: z.ZodObject<{
 // ── ElementMetadataViewerPropsSchema (const) ──
 declare const ElementMetadataViewerPropsSchema: z.ZodObject<{
     type: z.ZodEnum<{
-        flow: "flow";
         state_machine: "state_machine";
+        flow: "flow";
         permission: "permission";
     }>;
     name: z.ZodString;
@@ -7015,9 +7015,9 @@ declare const ElementNumberPropsSchema: z.ZodObject<{
     object: z.ZodString;
     field: z.ZodOptional<z.ZodString>;
     aggregate: z.ZodEnum<{
+        count: "count";
         min: "min";
         max: "max";
-        count: "count";
         sum: "sum";
         avg: "avg";
     }>;
@@ -7126,8 +7126,8 @@ declare const ElementRecordPickerPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strip>>>;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -7185,8 +7185,8 @@ declare const ElementTextInputPropsSchema: z.ZodObject<{
     inputType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         number: "number";
         email: "email";
-        url: "url";
         text: "text";
+        url: "url";
         password: "password";
         tel: "tel";
     }>>>;
@@ -7268,9 +7268,10 @@ declare const ElementTextPropsSchema: z.ZodObject<{
         defaultValue?: never;
     }>>]>;
     variant: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        caption: "caption";
-        heading: "heading";
         body: "body";
+        heading: "heading";
+        caption: "caption";
+        subheading: "subheading";
         h1: "h1";
         h2: "h2";
         h3: "h3";
@@ -7278,7 +7279,6 @@ declare const ElementTextPropsSchema: z.ZodObject<{
         h5: "h5";
         h6: "h6";
         overline: "overline";
-        subheading: "subheading";
     }>>>;
     align: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         left: "left";
@@ -7359,10 +7359,10 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodString>;
     field: z.ZodObject<{
         _lock: z.ZodOptional<z.ZodEnum<{
+            full: "full";
             none: "none";
             "no-overlay": "no-overlay";
             "no-delete": "no-delete";
-            full: "full";
         }>>;
         _lockReason: z.ZodOptional<z.ZodString>;
         _lockSource: z.ZodOptional<z.ZodEnum<{
@@ -7387,14 +7387,17 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             date: "date";
             record: "record";
             file: "file";
+            tags: "tags";
             email: "email";
-            url: "url";
+            phone: "phone";
+            user: "user";
             datetime: "datetime";
+            location: "location";
+            text: "text";
+            url: "url";
             time: "time";
             formula: "formula";
-            text: "text";
             textarea: "textarea";
-            phone: "phone";
             password: "password";
             secret: "secret";
             markdown: "markdown";
@@ -7410,7 +7413,6 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             lookup: "lookup";
             master_detail: "master_detail";
             tree: "tree";
-            user: "user";
             image: "image";
             avatar: "avatar";
             video: "video";
@@ -7419,7 +7421,6 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             autonumber: "autonumber";
             composite: "composite";
             repeater: "repeater";
-            location: "location";
             address: "address";
             json: "json";
             color: "color";
@@ -7428,7 +7429,6 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             signature: "signature";
             qrcode: "qrcode";
             progress: "progress";
-            tags: "tags";
             vector: "vector";
         }>;
         description: z.ZodOptional<z.ZodString>;
@@ -7504,8 +7504,8 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
                 date: "date";
                 file: "file";
                 datetime: "datetime";
-                time: "time";
                 text: "text";
+                time: "time";
                 currency: "currency";
                 select: "select";
                 lookup: "lookup";
@@ -7636,9 +7636,9 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
             object: z.ZodString;
             field: z.ZodString;
             function: z.ZodEnum<{
+                count: "count";
                 min: "min";
                 max: "max";
-                count: "count";
                 sum: "sum";
                 avg: "avg";
             }>;
@@ -7728,8 +7728,8 @@ declare const FieldWidgetPropsSchema: z.ZodObject<{
         readonly: z.ZodDefault<z.ZodBoolean>;
         requiredPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         maskingRule: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            email: "email";
             name: "name";
+            email: "email";
             phone: "phone";
             id_card: "id_card";
             bank_account: "bank_account";
@@ -10615,8 +10615,8 @@ type NotificationSeverity = z.input<typeof NotificationSeveritySchema>;
 declare const NotificationSeveritySchema: z.ZodEnum<{
     error: "error";
     success: "success";
-    warning: "warning";
     info: "info";
+    warning: "warning";
 }>;
 
 // ── NotificationType (type) ──
@@ -10624,11 +10624,11 @@ type NotificationType = z.input<typeof NotificationTypeSchema>;
 
 // ── NotificationTypeSchema (const) ──
 declare const NotificationTypeSchema: z.ZodEnum<{
-    inline: "inline";
+    alert: "alert";
     toast: "toast";
+    inline: "inline";
     banner: "banner";
     snackbar: "snackbar";
-    alert: "alert";
 }>;
 
 // ── ObjectCalendarProps (type) ──
@@ -10675,8 +10675,8 @@ declare const ObjectCalendarPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strip>>>;
     data: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
@@ -10693,15 +10693,15 @@ declare const ObjectFormPropsSchema: z.ZodObject<{
     objectName: z.ZodOptional<z.ZodString>;
     recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        view: "view";
-        edit: "edit";
         create: "create";
+        edit: "edit";
+        view: "view";
     }>>;
     formType: z.ZodOptional<z.ZodEnum<{
         split: "split";
-        drawer: "drawer";
-        modal: "modal";
         simple: "simple";
+        modal: "modal";
+        drawer: "drawer";
         tabbed: "tabbed";
         wizard: "wizard";
     }>>;
@@ -10868,8 +10868,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -10881,8 +10881,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -10928,8 +10928,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strip>>>;
     gantt: z.ZodOptional<z.ZodObject<{
@@ -10972,8 +10972,8 @@ declare const ObjectGanttPropsSchema: z.ZodObject<{
         lockField: z.ZodOptional<z.ZodString>;
         objectField: z.ZodOptional<z.ZodString>;
         summaryExtent: z.ZodOptional<z.ZodEnum<{
-            children: "children";
             self: "self";
+            children: "children";
         }>>;
         defaultCollapsedDepth: z.ZodOptional<z.ZodNumber>;
         dependencyTypes: z.ZodOptional<z.ZodBoolean>;
@@ -11089,8 +11089,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strip>>>;
     defaultSort: z.ZodOptional<z.ZodNever>;
@@ -11129,8 +11129,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11142,8 +11142,8 @@ declare const ObjectGridPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11963,8 +11963,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -11976,8 +11976,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12023,8 +12023,8 @@ declare const ObjectMapPropsSchema: z.ZodObject<{
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strip>>>;
     map: z.ZodOptional<z.ZodObject<{
@@ -12050,8 +12050,8 @@ declare const ObjectMasterDetailFormPropsSchema: z.ZodObject<{
     objectName: z.ZodOptional<z.ZodString>;
     recordId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     mode: z.ZodOptional<z.ZodEnum<{
-        edit: "edit";
         create: "create";
+        edit: "edit";
     }>>;
     formType: z.ZodOptional<z.ZodEnum<{
         simple: "simple";
@@ -12157,12 +12157,12 @@ declare const ObjectMetricPropsSchema: z.ZodObject<{
     colorVariant: z.ZodOptional<z.ZodEnum<{
         default: "default";
         success: "success";
+        warning: "warning";
         danger: "danger";
         blue: "blue";
         teal: "teal";
         orange: "orange";
         purple: "purple";
-        warning: "warning";
     }>>;
     aggregate: z.ZodOptional<z.ZodUnknown>;
     filter: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -12291,8 +12291,8 @@ declare const ObjectTreePropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12304,8 +12304,8 @@ declare const ObjectTreePropsSchema: z.ZodObject<{
             url: z.ZodString;
             method: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
                 GET: "GET";
-                POST: "POST";
                 PUT: "PUT";
+                POST: "POST";
                 DELETE: "DELETE";
                 PATCH: "PATCH";
             }>>>;
@@ -12435,8 +12435,8 @@ declare const PageAccordionProps: z.ZodObject<{
     }, z.core.$strict>>;
     allowMultiple: z.ZodDefault<z.ZodBoolean>;
     variant: z.ZodDefault<z.ZodEnum<{
-        card: "card";
         flush: "flush";
+        card: "card";
     }>>;
     aria: z.ZodOptional<z.ZodObject<{
         ariaLabel: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
@@ -18459,14 +18459,14 @@ declare const RecordActivityProps: z.ZodObject<{
         file: "file";
         email: "email";
         system: "system";
-        sharing: "sharing";
         approval: "approval";
+        sharing: "sharing";
+        event: "event";
         comment: "comment";
+        note: "note";
         field_change: "field_change";
         task: "task";
-        event: "event";
         call: "call";
-        note: "note";
         record_create: "record_create";
         record_delete: "record_delete";
     }>, z.ZodString]>>>;
@@ -18527,9 +18527,9 @@ declare const RecordAlertActionSchema: z.ZodObject<{
         default: "default";
         link: "link";
         secondary: "secondary";
-        destructive: "destructive";
-        outline: "outline";
         ghost: "ghost";
+        outline: "outline";
+        destructive: "destructive";
     }>>;
 }, z.core.$strict>;
 
@@ -18538,8 +18538,8 @@ declare const RecordAlertProps: z.ZodObject<{
     severity: z.ZodOptional<z.ZodEnum<{
         error: "error";
         success: "success";
-        warning: "warning";
         info: "info";
+        warning: "warning";
     }>>;
     title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodType<Record<string, string> & {
         key?: never;
@@ -18608,9 +18608,9 @@ declare const RecordAlertProps: z.ZodObject<{
             default: "default";
             link: "link";
             secondary: "secondary";
-            destructive: "destructive";
-            outline: "outline";
             ghost: "ghost";
+            outline: "outline";
+            destructive: "destructive";
         }>>;
     }, z.core.$strict>>;
     dismissible: z.ZodOptional<z.ZodBoolean>;
@@ -18638,14 +18638,14 @@ declare const RecordChatterProps: z.ZodObject<{
             file: "file";
             email: "email";
             system: "system";
-            sharing: "sharing";
             approval: "approval";
+            sharing: "sharing";
+            event: "event";
             comment: "comment";
+            note: "note";
             field_change: "field_change";
             task: "task";
-            event: "event";
             call: "call";
-            note: "note";
             record_create: "record_create";
             record_delete: "record_delete";
         }>, z.ZodString]>>>;
@@ -18885,15 +18885,15 @@ declare const RecordQuickActionsProps: z.ZodObject<{
         default: "default";
         link: "link";
         secondary: "secondary";
-        destructive: "destructive";
-        outline: "outline";
         ghost: "ghost";
+        outline: "outline";
+        destructive: "destructive";
     }>>;
     size: z.ZodOptional<z.ZodEnum<{
         default: "default";
+        icon: "icon";
         sm: "sm";
         lg: "lg";
-        icon: "icon";
     }>>;
 }, z.core.$strict>;
 
@@ -18924,8 +18924,8 @@ declare const RecordRelatedListProps: z.ZodObject<{
     sort: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodObject<{
         field: z.ZodString;
         order: z.ZodEnum<{
-            asc: "asc";
             desc: "desc";
+            asc: "asc";
         }>;
     }, z.core.$strict>>]>>;
     limit: z.ZodDefault<z.ZodNumber>;
@@ -27034,7 +27034,7 @@ declare const WidgetColorVariantSchema: z.ZodEnum<{
 
 // ── actionForm (const) ──
 declare const actionForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27056,14 +27056,14 @@ declare const actionForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27234,7 +27234,7 @@ declare const actionForm: {
 
 // ── appForm (const) ──
 declare const appForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27256,14 +27256,14 @@ declare const appForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27491,7 +27491,7 @@ declare function compileListViewGroupRowsQuery(view: Pick<ListViewGroupQuerySour
 
 // ── dashboardForm (const) ──
 declare const dashboardForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27513,14 +27513,14 @@ declare const dashboardForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27691,7 +27691,7 @@ declare const dashboardForm: {
 
 // ── datasetForm (const) ──
 declare const datasetForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27713,14 +27713,14 @@ declare const datasetForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -27970,7 +27970,7 @@ declare function objectNavTargetExclusivity(item: {
 
 // ── pageForm (const) ──
 declare const pageForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -27992,14 +27992,14 @@ declare const pageForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -28176,7 +28176,7 @@ declare function reactBlockTagFor(schemaType: string): string;
 
 // ── reportForm (const) ──
 declare const reportForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -28198,14 +28198,14 @@ declare const reportForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
@@ -28396,7 +28396,7 @@ declare function validateActionParams(resolved: ResolvedActionParam[], bag: Reco
 
 // ── viewForm (const) ──
 declare const viewForm: {
-    type: "split" | "drawer" | "modal" | "simple" | "tabbed" | "wizard";
+    type: "split" | "simple" | "modal" | "drawer" | "tabbed" | "wizard";
     layout?: "grid" | "inline" | "vertical" | "horizontal" | undefined;
     columns?: number | undefined;
     title?: string | undefined;
@@ -28418,14 +28418,14 @@ declare const viewForm: {
         provider: "api";
         read?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;
         } | undefined;
         write?: {
             url: string;
-            method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH";
             headers?: Record<string, string> | undefined;
             params?: Record<string, unknown> | undefined;
             body?: unknown;

From 6d8fc4f12fcdaa8fa25e9abb698aba308ce64b84 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Fri, 18 Sep 2026 16:48:14 +0000
Subject: [PATCH 11/11] =?UTF-8?q?docs(spec):=20correct=20the=20declined-le?=
 =?UTF-8?q?g=20reason=20=E2=80=94=20the=20churn=20claim=20was=20cache-tain?=
 =?UTF-8?q?ted?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous commit message and this docblock justified declining the
pre-existing `IScopedContext` leak partly on "330 lines of order-only churn in
the ui shard". That measurement was taken against a dist turbo served from the
shared cache, so it is VOID, not disproven. From a forced build this tree
emits `ui.txt` and `automation.txt` byte-identical to main, and no such churn
exists.

The decision is unchanged and now rests only on what survives measurement: the
leak is pre-existing (since #5945, on base as on head), it is outside this
card's ruling, and closing it takes TWO names rather than one — so it is a
change to a face this card does not own, with its own review.

Claude-Session: https://claude.ai/code/session_01AmH9bKvGoLjiY86Q4Z3og2
Co-authored-by: Claude <noreply@anthropic.com>
---
 packages/spec/src/data/hook-api.ts | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/packages/spec/src/data/hook-api.ts b/packages/spec/src/data/hook-api.ts
index e609e67917c..09f44c5b794 100644
--- a/packages/spec/src/data/hook-api.ts
+++ b/packages/spec/src/data/hook-api.ts
@@ -344,20 +344,16 @@ export interface HookApi {
  *     repository — measured, at head, with the three-name variant applied. A
  *     one-name patch publishes a HALF closure that READS closed, which is the
  *     declared-not-enforced shape this repo refuses.
- *   - The second of those two names is not free. Adding
- *     `IScopedObjectRepository` to this entry moves the dts bundler's module
- *     order enough to reorder members inside object type literals in the
- *     UNRELATED `ui` shard: 330 lines, which `check:api-surface-declarations`
- *     reports as "33 reshaped" and asks a reviewer to rule on. Measured as
- *     order-only — identical token multiset, identical line count, nothing
- *     added, removed or renamed — and the generator is stable against a fixed
- *     dist, so it is noise rather than drift. But it is a verdict somebody has
- *     to read, in a shard this card does not touch.
- *
- * Two names with a clean surface delta, or four names plus an adjudication in
- * someone else's shard: that is a trade for its own card and its own review,
- * not a rider on a FAIL remediation. The pre-existing leak is reported with
- * both measurements so that card can be written without re-deriving them.
+ *   - So it is a TWO-name change to a face this card does not own. Both names
+ *     are declared in `contracts/scoped-context.ts` and neither is introduced
+ *     to this entry by anything in this diff: `HookContext.api` has carried
+ *     the leak since #5945, on this card's base exactly as on its head. What
+ *     this file owes is the two names its OWN new declarations introduced.
+ *
+ * So: fixed here, the instances this card created; reported, the pre-existing
+ * one, with the measurement that it takes two names rather than one — which is
+ * the part a reader would otherwise get wrong. It is a card of its own, with
+ * its own review, not a rider on a FAIL remediation.
  *
  * ⛔ `check:entry-nameability` is NOT the instrument that answers this. By its
  * own docblock it probes the CALL surface of VALUE exports that have a call