graphddb 0.3.1 → 0.4.1

package/dist/{types-DuJ08bgc.d.ts → types-BWOrWcbd.d.ts}

@@ -227,6 +227,16 @@ interface Param<out T> {
      * `{item.<field>}` templates. `undefined` for scalar params.
      */
     readonly element?: Readonly<Record<string, Param<unknown>>>;
+    /**
+     * Optional human-readable description of the parameter (issue #154), supplied
+     * via `param.string({ description })` etc. Pure documentation metadata — it does
+     * NOT affect the runtime descriptor (`kind` / `literals`) the planner reads for
+     * execution. When present it is propagated to the param's {@link
+     * import('./ir.js').ParamDescriptor} and then to the serialized
+     * {@link import('../spec/types.js').ParamSpec} in `operations.json`. Absent →
+     * unchanged output (backward compatible).
+     */
+    readonly description?: string;
 }
 /** A `Param` whose represented value type is `string`. */
 type StringParam = Param<string>;
@@ -249,26 +259,41 @@ type ArrayParam<E extends ArrayElementShape> = Param<ElementOf<E>[]> & {
 };
 /** Allowed scalar value types a placeholder may stand in for. */
 type ParamValue = string | number;
+/**
+ * Options accepted by the placeholder factories (issue #154). Currently carries
+ * only the optional human-readable {@link Param.description} — pure documentation
+ * metadata that does not affect the runtime descriptor. The object form is
+ * additive: `param.string()` (no options) is unchanged.
+ */
+interface ParamOptions {
+    /** Optional human-readable description, propagated to `operations.json`. */
+    readonly description?: string;
+}
 /**
  * Placeholder factory. Each call returns a branded {@link Param} carrying both
- * the TypeScript value type and a runtime descriptor.
+ * the TypeScript value type and a runtime descriptor. Each scalar factory accepts
+ * an optional {@link ParamOptions} (issue #154) carrying a `description` — pure
+ * documentation propagated to `operations.json`; the no-argument call is unchanged.
  */
 declare const param: {
     /** A placeholder for a `string` value. */
-    readonly string: () => StringParam;
+    readonly string: (options?: ParamOptions) => StringParam;
     /** A placeholder for a `number` value. */
-    readonly number: () => NumberParam;
+    readonly number: (options?: ParamOptions) => NumberParam;
     /**
      * A placeholder constrained to one of the given literal values. The value
      * type of the resulting {@link Param} is the **union of the literals**, so it
-     * is preserved precisely in the IR and the inferred definition types.
+     * is preserved precisely in the IR and the inferred definition types. A final
+     * plain-object argument is read as {@link ParamOptions} (a `description`),
+     * distinguished from the `string` / `number` literal values.
      *
      * @example
      * ```ts
      * param.literal('active', 'disabled'); // Param<'active' | 'disabled'>
+     * param.literal('active', 'disabled', { description: 'Account state.' });
      * ```
      */
-    readonly literal: <const L extends readonly [ParamValue, ...ParamValue[]]>(...values: L) => LiteralParam<L[number]>;
+    readonly literal: <const L extends readonly [ParamValue, ...ParamValue[]]>(...valuesAndOptions: [...L] | [...L, ParamOptions]) => LiteralParam<L[number]>;
     /**
      * A placeholder for an **array** parameter whose elements have the given field
      * shape. Used by `defineTransaction`'s `tx.forEach(p.<arrayParam>, …)` to bind
@@ -280,7 +305,7 @@ declare const param: {
      * // Param<{ userId: string; role: string }[]>
      * ```
      */
-    readonly array: <const E extends ArrayElementShape>(element: E) => ArrayParam<E>;
+    readonly array: <const E extends ArrayElementShape>(element: E, options?: ParamOptions) => ArrayParam<E>;
 };
 /** Runtime type guard: is `value` a parameter placeholder? */
 declare function isParam(value: unknown): value is Param<unknown>;
@@ -1765,6 +1790,21 @@ interface ConditionTree {
 interface WriteDefinitionOptions {
     /** Optional declarative write condition (subset). */
     readonly condition?: ConditionInput;
+    /**
+     * Optional human-readable description of the command use case (issue #154). Pure
+     * documentation — propagated to `operations.json` and the generated Python
+     * repository-method docstring. Omit for unchanged output.
+     */
+    readonly description?: string;
+}
+/** Options accepted by the read `define*` entry points (issue #154). */
+interface ReadDefinitionOptions {
+    /**
+     * Optional human-readable description of the query use case (issue #154). Pure
+     * documentation — propagated to `operations.json` and the generated Python
+     * repository-method docstring. Omit for unchanged output.
+     */
+    readonly description?: string;
 }
 /**
  * Identifies the entity an operation targets. `name` is the model class name
@@ -1790,6 +1830,13 @@ interface ParamDescriptor<T = unknown> {
      * descriptors. `undefined` for scalar params.
      */
     readonly element?: Readonly<Record<string, ParamDescriptor>>;
+    /**
+     * Optional human-readable description of the parameter (issue #154), carried
+     * from a `param.*({ description })` placeholder. Pure documentation — it does
+     * not affect `kind` / `literals` (the execution-relevant descriptor). Propagated
+     * to the serialized {@link import('../spec/types.js').ParamSpec}.
+     */
+    readonly description?: string;
     /** Parameters are always required (no optional params in this phase). */
     readonly required: true;
 }
@@ -1843,6 +1890,15 @@ interface OperationDefinition<T extends DDBModel, Op extends OperationKind, K, S
      * when no condition is attached or for reads (issue #46).
      */
     readonly condition?: ConditionInput;
+    /**
+     * Optional human-readable description of the definition (issue #154), supplied
+     * via the entry-point options (`defineQuery(..., { description })` etc.). Pure
+     * documentation — propagated to the serialized {@link
+     * import('../spec/types.js').QuerySpec.description} /
+     * {@link import('../spec/types.js').CommandSpec.description} and to the generated
+     * Python repository-method docstring. It does not affect execution.
+     */
+    readonly description?: string;
     /** Collected parameters: name → descriptor (value type preserved in `P`). */
     readonly params: P;
     /** @internal Phantom carrier so the entity type `T` is retained on the node. */
@@ -2057,7 +2113,17 @@ type ProjectionMap = Readonly<Record<string, ProjectionTransform>>;
  * @param n The preview length bound (a positive integer).
  * @throws if `n` is not a positive integer.
  */
-declare function preview(path: EffectPath, n: number): ProjectionTransform;
+/**
+ * A value position the projection helpers accept: either a literal path string or
+ * a symbolic `source.<field>` reference (a `{ path }` carrier — the `SourceRef` the
+ * `@maintainedFrom` / versioned `(self, source) =>` callbacks mint, issue #152).
+ * Typed structurally (no import) so `entity-writes` stays free of a back-edge to
+ * the decorator layer; the symbolic ref's branded type still flows through.
+ */
+type PathLike = EffectPath | {
+    readonly path: EffectPath;
+};
+declare function preview(path: PathLike, n: number): ProjectionTransform;
 /**
  * Standalone authoring helper for an `identity` {@link ProjectionTransform}: copy
  * the source `path` through unchanged. The recorder-free counterpart to
@@ -2069,7 +2135,7 @@ declare function preview(path: EffectPath, n: number): ProjectionTransform;
  *
  * @param path The source value copied through unchanged.
  */
-declare function identity(path: EffectPath): ProjectionTransform;
+declare function identity(path: PathLike): ProjectionTransform;
 /**
  * The **path** a maintenance write travels (shared vocabulary, epic #118 A/B
  * reconciliation — RFC §5.1 / issue #121 are the authority). `mutation` lands the
@@ -2752,446 +2818,72 @@ declare function mutation(name: string, body: MutationBody): CommandPlan;
 declare const definePlan: typeof mutation;
 
 /**
- * `defineView` / `defineProjection` — the maintained **view** and **external
- * projection** definition DSL (Epic #118 Phase 2, issue #132 child M).
- *
- * ## Where this sits in the `define*` family
- *
- * This module extends the record-of-definitions pattern of
- * `src/define/define.ts` (`defineQuery`/`defineList`/… grouped by
- * `defineQueries`/`defineCommands`) with two new families that declare a single
- * **view** node → IR:
- *
- * - {@link defineView} (`materializedView`) — declares an INDEPENDENT view row
- *   maintained from the lifecycle events of one or more **source** entities. The
- *   view row is its OWN modelled row (a `DDBModel` with its own `keys`), NOT a
- *   field of any source entity — the "特定エンティティのフィールドでない単体行" of
- *   RFC §5.3. RFC §5.3:
- *   ```ts
- *   defineView(UserThreadListModel, {
- *     pattern: 'materializedView',
- *     source: [{ entity: () => PostModel, maintainedOn: ['Post.created'], … }, …],
- *     keys:   { userId: '$.entity.userId' },
- *     fields: { … },        // per-source projection of the view row
- *     write:  { updateMode: 'stream' },
- *   })
- *   ```
- * - {@link defineProjection} (`externalProjection`) — declares a stream + idempotency
- *   projection of a source entity into an EXTERNAL sink (BigQuery / S3 / OpenSearch
- *   in production; the CDC emulator in dev/test). RFC §5.3:
- *   ```ts
- *   defineProjection('TestCaseResultBQ', {
- *     pattern: 'externalProjection',
- *     source: () => TestCaseResultModel,
- *     via: 'stream',
- *     idempotencyKey: 'resultId',
- *   })
- *   ```
- *
- * `defineViews({...})` / `defineProjections({...})` take a record of these
- * definition nodes and return the same record (typed), forming the IR the
- * maintenance graph (#124, extended here as the third maintenance source after
- * relations and aggregates) and the projection sink consume — exactly the
- * `defineQueries`/`defineCommands`样式.
- *
- * ## Why a view is its own definition (not a relation `@hasMany`)
- *
- * A relation/aggregate maintainer (#124) hangs off a MODELLED entity row — its
- * destination is a `DDBModel` class resolved by the relation owner, and its
- * single source is the relation's `to`. A **materialized view** is the
- * complementary case the RFC §5.3 calls out: an independent row fed by SEVERAL
- * foreign sources (none of which is the view itself). So it cannot be a relation
- * decorator on a source; it is its own top-level declaration whose destination is
- * the dedicated **view model** row. That view model is a normal `DDBModel` (so the
- * maintenance graph / drain / rebuild resolve its key with the SAME machinery they
- * use for a relation owner — no parallel key system), but it is the owner of NO
- * relation: the sources point INTO it, declared here rather than on the sources.
- *
- * ## Scope boundary (payload-同梱; multi-source as per-source slices)
- *
- * Each `source` projects ONLY from its own payload (the same payload-同梱 rule
- * the relation maintenance graph enforces — RFC §4.A.6 `requiredContext` /
- * write-time-fetch is a deferred follow-up). A multi-source view is therefore
- * maintained as a UNION of per-source slices on one view row: `Post.created`
- * updates the Post-projected `fields`, `Thread.read` updates the Thread-projected
- * `fields`, each converging the shared view row through the K (#130) stream →
- * outbox → drain path. A field whose value must combine attributes from more than
- * one source in a single write (a cross-source join at maintenance time) is the
- * `requiredContext` case and is out of scope — see the module-level note and the
- * issue report.
- */
-
-type AnyModelClass = abstract new (...args: any[]) => DDBModel;
-/** A source-entity factory: a model class or a `ModelStatic` wrapper. */
-type SourceFactory = () => AnyModelClass | ModelStatic<DDBModel>;
-/** A bare-string identity shorthand or an explicit `w.transform(...)` IR node. */
-type ProjectionEntry = ProjectionTransform | string;
-/**
- * Build a {@link MembershipPredicate} for a sparse view (Epic #118 pattern 6 / #133).
- * The view row is PUT when the predicate holds and DELETED when it flips false. The
- * `path` is normalized to a payload-rooted source value (a bare field name becomes
- * `$.entity.<field>`).
+ * Decorator-metadata → maintenance-graph `ViewDefinition` adapter (issue #152).
  *
- * Named `whenMember` (not `when`) to avoid colliding with the transaction-condition
- * `when` helper (`src/define/transaction.ts`).
+ * ## What this replaces
  *
- * @example `whenMember('status', 'eq', 'active')` — the view row exists only while
- *   `status === 'active'`.
- * @example `whenMember('archived', 'falsy')` — the view row exists only while
- *   `archived` is falsy.
- */
-declare function whenMember(field: string, op: MembershipPredicateOp, value?: unknown): MembershipPredicate;
-/**
- * One source contributing to a maintained view (issue #132). The source entity's
- * lifecycle events ({@link maintainedOn}) drive the maintenance; its payload is
- * projected into the view row's {@link fields} (payload-同梱). When the source
- * maintains an ordered/bounded slice (a collection-shaped view) it declares
- * {@link collection}; otherwise it maintains a single snapshot slice.
- */
-interface ViewSource {
-    /** Resolves the source entity whose lifecycle drives this slice of the view. */
-    readonly entity: SourceFactory;
-    /**
-     * The cross-entity triggers this source fires on (`'<Entity>.<event>'`, the
-     * shared `created`/`updated`/`removed` vocabulary). The entity segment must be
-     * the source entity's logical name (the maintenance graph validates it).
-     */
-    readonly maintainedOn: readonly string[];
-    /**
-     * The view-row key binding for THIS source: view-row key field → a path-rooted
-     * source value (`$.entity.<field>` / `$.input.<field>`). Resolves which view
-     * row this source event maintains. When omitted, the view-level {@link
-     * ViewDefinitionInput.keys} is used (the common case — every source keys the
-     * view row the same way).
-     */
-    readonly keys?: Readonly<Record<string, EffectPath>>;
-    /**
-     * The projection of THIS source's payload into the view row (target attribute →
-     * identity shorthand string / `w.transform(...)`). When omitted, the view-level
-     * {@link ViewDefinitionInput.fields} is used.
-     */
-    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
-    /**
-     * Declares this source maintains a bounded, ordered COLLECTION slice of the view
-     * row (e.g. "latest N posts") rather than a single snapshot. The `field` names
-     * the view-row attribute holding the list; `maxItems` / `order` shape it.
-     */
-    readonly collection?: {
-        readonly field: string;
-        readonly maxItems?: number;
-        readonly order?: 'ASC' | 'DESC';
-        /** The source path the collection orders by + trims on (e.g. `$.entity.createdAt`). */
-        readonly orderBy?: EffectPath;
-    };
-    /**
-     * Sparse-view predicate (Epic #118 pattern 6 / #133): when present, this source
-     * maintains a MEMBERSHIP slice — the view row is PUT (projected) while the predicate
-     * holds and DELETED when it flips false (and always deleted on a source `removed`).
-     * Build it with {@link whenMember} (e.g. `whenMember('status', 'eq', 'active')`). Mutually
-     * exclusive with {@link collection} (a row either appears/disappears or holds a list).
-     */
-    readonly when?: MembershipPredicate;
-}
-/** The author-facing input to {@link defineView}. */
-interface ViewDefinitionInput {
-    /** The maintenance preset — `'materializedView'` (snapshot/collection) or `'sparseView'` (membership). */
-    readonly pattern?: 'materializedView' | 'sparseView';
-    /** One or more sources whose lifecycle events maintain the view row. */
-    readonly source: ViewSource | readonly ViewSource[];
-    /**
-     * The default view-row key binding (view-row key field → path-rooted source
-     * value). A source may override it with its own `keys`. At least one of the
-     * view-level `keys` or every source's `keys` must be present.
-     */
-    readonly keys?: Readonly<Record<string, EffectPath>>;
-    /** The default per-source projection of the view row (source may override). */
-    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
-    /** Maintenance-write declaration shared by the sources (`updateMode` / `consistency`). */
-    readonly write?: {
-        readonly updateMode?: MaintainUpdateMode;
-        readonly consistency?: MaintainConsistency;
-    };
-}
-/** Marks an object as a {@link ViewDefinition} IR node. */
-declare const VIEW_DEFINITION_MARKER: unique symbol;
-/**
- * The global registry of declared {@link ViewDefinition}s (issue #132). A
- * `defineView(...)` registers itself here so the compile-side global maintenance
- * graph (and the linter) discovers view maintainers WITHOUT the caller threading
- * the definitions through — the same way `@model` auto-registers an entity in
- * `MetadataRegistry`. A {@link generation} counter (bumped on every register /
- * clear) lets a cache keyed off it invalidate when a view is added, so a
- * newly-declared view is never silently dropped from the compile path.
- */
-declare class ViewRegistry {
-    private static readonly views;
-    private static gen;
-    /** Register (or replace, by view class) a declared view. Bumps the generation. */
-    static register(def: ViewDefinition): void;
-    /** Every registered view, in declaration order. */
-    static getAll(): readonly ViewDefinition[];
-    /** The monotonic generation counter (changes whenever the set of views changes). */
-    static get generation(): number;
-    /** Forget every registered view (test reset). Bumps the generation. */
-    static clear(): void;
-}
-/**
- * The lowered per-source maintenance slice of a view — one entry per (source ×
- * trigger), carrying the resolved source class, the validated triggers, the view
- * row key binding, and the projection. Consumed by the maintenance graph (#124)
- * which synthesizes the A-defined `SnapshotEffect` / `CollectionEffect` from it.
+ * The old `defineView` / `defineVersioned` builders (deleted) registered
+ * `ViewDefinition`s into a side `ViewRegistry`, which the maintenance graph read.
+ * That builder carried a registration side-effect + a `generation` counter (a
+ * silent-drop guard). This adapter removes that whole path: it derives the SAME
+ * `ViewDefinition` IR purely from the declarative `MetadataRegistry` — the
+ * Contract-layer SSoT, whose own `generation` counter is the single
+ * invalidation source — so a view declared via `@model({ kind })` + `@maintainedFrom`
+ * (and a versioned relation declared via `@hasOne/@hasMany` `pattern`) is discovered
+ * with no separate registry.
+ *
+ * ## IR invariance
+ *
+ * The `ViewDefinition` / `ViewSourceSlice` shapes are UNCHANGED. The maintenance
+ * graph, the K (#130) stream/drain, and the L (#131) rebuild consume the adapter's
+ * output exactly as they consumed `ViewRegistry.getAll()`. Only the SOURCE of the
+ * definitions moved from a builder side-effect to declarative metadata.
+ *
+ * ## Order independence (issue #152 hardening)
+ *
+ * Stacked `@maintainedFrom` declarations carry no order meaning. The adapter rejects
+ * — symmetrically, so the error is identical whichever order the decorators are
+ * stacked — any two declarations on the same view that:
+ *   1. write the SAME projection target attribute (ambiguous duplicate projection);
+ *   2. maintain the SAME `collection.field`;
+ *   3. bind the SAME view-key field to a DIFFERENT source path (the view-row identity
+ *      would be inconsistent across sources).
+ * A legitimate multi-source view (different sources filling DIFFERENT fields, all
+ * binding the SAME key the SAME way) is fine.
  */
+
+type AnyModelClass = abstract new (...args: any[]) => any;
+/** The view source slice IR the maintenance graph consumes (one per source × view). */
 interface ViewSourceSlice {
-    /** The resolved source model class (the lifecycle origin / projected payload). */
     readonly sourceClass: AnyModelClass;
-    /** The validated triggers this slice fires on. */
     readonly maintainedOn: readonly MaintainTrigger[];
-    /** The view-row key binding (view-row key field → path-rooted source value). */
     readonly keys: Readonly<Record<string, EffectPath>>;
-    /** The projection map (target attribute → `w.transform(...)` IR). */
     readonly project: ProjectionMap;
-    /** Bounded/ordered collection options when this slice maintains a list. */
     readonly collection?: {
         readonly field: string;
         readonly maxItems?: number;
         readonly orderBy?: EffectPath;
         readonly orderDir?: 'ASC' | 'DESC';
     };
-    /**
-     * Sparse-view membership predicate (Epic #118 pattern 6 / #133) when this slice
-     * maintains a put/delete membership row. The maintenance graph synthesizes a
-     * `MembershipEffect` (not a snapshot) from it.
-     */
     readonly predicate?: MembershipPredicate;
 }
-/**
- * The IR for one `defineView` node — an independent materialized-view row
- * maintained from one or more source entities. The `name` is the view's logical
- * identity; `viewClass` is the dedicated view model the row lives on (the
- * maintenance destination); `slices` are the lowered per-source maintenance
- * contributions the maintenance graph turns into effects.
- */
+/** The view definition IR — an independent view row maintained from one or more sources. */
 interface ViewDefinition {
-    readonly [VIEW_DEFINITION_MARKER]: true;
-    /** The view's logical name (e.g. `'UserThreadList'`). */
     readonly name: string;
-    /** The dedicated view model class the maintained row lives on (the destination). */
     readonly viewClass: AnyModelClass;
-    /** The maintenance preset (`'materializedView'` or `'sparseView'`). */
     readonly pattern: 'materializedView' | 'sparseView';
-    /** The lowered per-source maintenance slices. */
     readonly slices: readonly ViewSourceSlice[];
-    /** The path the maintenance writes travel (`mutation` / `stream`). */
-    readonly updateMode?: MaintainUpdateMode;
-    /** The consistency the maintenance writes land under. */
-    readonly consistency?: MaintainConsistency;
-}
-/** Runtime guard: is `value` a {@link ViewDefinition}? */
-declare function isViewDefinition(value: unknown): value is ViewDefinition;
-/**
- * Define a single maintained **view** (`materializedView`, issue #132): an
- * independent view row (on the dedicated `view` model) maintained from one or more
- * source entities' lifecycle events, projecting each source's payload (payload-同梱)
- * into the view row. The returned {@link ViewDefinition} is the IR the maintenance
- * graph (#124) consumes as a third maintenance source (after relations /
- * aggregates), so a view row converges through the SAME stream → outbox → drain
- * path (K, #130).
- *
- * @param view The dedicated view model class the maintained row lives on (a normal
- *   `DDBModel` with its own `keys`). Its logical name is the view's `name`.
- * @param input The view's sources / key binding / projection / write declaration.
- *
- * @example
- * ```ts
- * const UserThreadList = defineView(UserThreadListModel, {
- *   pattern: 'materializedView',
- *   keys: { userId: '$.entity.userId' },
- *   source: [
- *     { entity: () => PostModel, maintainedOn: ['Post.created'],
- *       fields: { lastPostId: 'postId', lastPostAt: 'createdAt' } },
- *     { entity: () => ThreadModel, maintainedOn: ['Thread.updated'],
- *       fields: { threadTitle: 'title' } },
- *   ],
- *   write: { updateMode: 'stream' },
- * });
- * ```
- */
-declare function defineView(view: AnyModelClass | ModelStatic<DDBModel>, input: ViewDefinitionInput): ViewDefinition;
-/** A record of view-name → {@link ViewDefinition}. */
-type ViewDefinitionMap = Record<string, ViewDefinition>;
-/**
- * Group a record of {@link defineView} nodes into the view IR consumed by the
- * maintenance graph (#124). Validates that every entry is a `defineView` node —
- * the `defineQueries`/`defineCommands` 様式.
- */
-declare function defineViews<const D extends ViewDefinitionMap>(definitions: D): D;
-/** The author-facing input to {@link defineVersioned}. */
-interface VersionedDefinitionInput {
-    /** The maintenance preset — `'versioned'`. */
-    readonly pattern?: 'versioned';
-    /** Resolves the source entity whose lifecycle events maintain both rows. */
-    readonly source: SourceFactory;
-    /**
-     * The triggers that maintain a new version (`'<Entity>.<event>'`). Typically
-     * `['Doc.created', 'Doc.updated']` — every persisted revision advances the latest
-     * pointer and appends a history row.
-     */
-    readonly maintainedOn: readonly string[];
-    /**
-     * The LATEST-pointer row's key binding (latest-model key field → path-rooted source
-     * value). It must NOT include the version discriminator — the latest row is
-     * OVERWRITTEN on each revision (one row per source identity, e.g. `{ docId:
-     * '$.entity.docId' }`).
-     */
-    readonly latestKeys: Readonly<Record<string, EffectPath>>;
-    /**
-     * The HISTORY row's key binding (history-model key field → path-rooted source value).
-     * It MUST include the version discriminator so each revision is a NEW row (append-only
-     * history, e.g. `{ docId: '$.entity.docId', version: '$.entity.version' }`).
-     */
-    readonly historyKeys: Readonly<Record<string, EffectPath>>;
-    /** The projection of the source payload into BOTH rows (target attribute → source). */
-    readonly fields: Readonly<Record<string, ProjectionEntry>>;
-    /** Maintenance-write declaration shared by both rows (`updateMode` / `consistency`). */
-    readonly write?: {
-        readonly updateMode?: MaintainUpdateMode;
-        readonly consistency?: MaintainConsistency;
-    };
-}
-/**
- * The pair of {@link ViewDefinition}s a {@link defineVersioned} lowers to — the
- * latest-pointer snapshot row and the append-only history snapshot row.
- */
-interface VersionedDefinition {
-    /** The LATEST-pointer row (a snapshot, overwritten on each revision). */
-    readonly latest: ViewDefinition;
-    /** The append-only HISTORY row (one snapshot row per version). */
-    readonly history: ViewDefinition;
-}
-/**
- * Define a **versioned / latest-pointer** maintained access path (Epic #118 pattern 8,
- * issue #133): from one source revision, maintain a LATEST-pointer row (overwritten in
- * place) AND append a HISTORY row (one per version) in a single composed write.
- *
- * ## Lowering = composition of two snapshot effects (no new effect)
- *
- * Per the design hint "既存の snapshot（latest）+ 別行追記（history）の合成で表現できるか",
- * `versioned` is **pure composition** of the existing {@link SnapshotEffect}:
- *
- * - the LATEST row is a snapshot keyed by the source identity WITHOUT the version
- *   (`latestKeys`) → re-projecting the same key OVERWRITES the pointer in place;
- * - the HISTORY row is a snapshot keyed by the source identity PLUS the version
- *   (`historyKeys`) → each revision resolves a NEW row, so history is append-only.
- *
- * Both are lowered as {@link defineView} (`materializedView`) nodes — the maintenance
- * graph synthesizes a `SnapshotEffect` per source trigger, and because the two rows
- * resolve to DIFFERENT destination rows (distinct models / keys) the same-row collision
- * guard is satisfied and BOTH fire from the one source mutation: the latest pointer and
- * the history row land together (in one atomic tx for `updateMode: 'mutation'`, or
- * converge through the stream → drain path for `'stream'`). There is NO new maintenance
- * primitive — the existing snapshot pipeline (sync #127 / stream #130 / rebuild #131)
- * carries both.
- *
- * @param latest The dedicated LATEST-pointer view model (one row per source identity).
- * @param history The dedicated HISTORY view model (one row per version).
- * @param input The source / triggers / key bindings / projection / write declaration.
- *
- * @example
- * ```ts
- * const DocVersioned = defineVersioned(DocLatestModel, DocVersionModel, {
- *   pattern: 'versioned',
- *   source: () => DocModel,
- *   maintainedOn: ['Doc.created', 'Doc.updated'],
- *   latestKeys: { docId: '$.entity.docId' },
- *   historyKeys: { docId: '$.entity.docId', version: '$.entity.version' },
- *   fields: { docId: 'docId', version: 'version', title: 'title' },
- *   write: { updateMode: 'mutation' },
- * });
- * ```
- */
-declare function defineVersioned(latest: AnyModelClass | ModelStatic<DDBModel>, history: AnyModelClass | ModelStatic<DDBModel>, input: VersionedDefinitionInput): VersionedDefinition;
-/** Marks an object as a {@link ProjectionDefinition} IR node. */
-declare const PROJECTION_DEFINITION_MARKER: unique symbol;
-/** The transport a projection travels — only `stream` (async) in this phase. */
-type ProjectionVia = 'stream';
-/** The author-facing input to {@link defineProjection}. */
-interface ProjectionDefinitionInput {
-    /** The maintenance preset — `'externalProjection'`. */
-    readonly pattern?: 'externalProjection';
-    /** Resolves the source entity whose lifecycle events are projected to the sink. */
-    readonly source: SourceFactory;
-    /** The transport (`'stream'` — async CDC; the only supported value this phase). */
-    readonly via?: ProjectionVia;
-    /**
-     * The source attribute whose value is the **idempotency key** for at-least-once
-     * de-duplication at the sink (e.g. `'resultId'`). A redelivered source event
-     * with the same key is folded to one sink upsert.
-     */
-    readonly idempotencyKey: string;
-    /**
-     * The lifecycle events projected. Defaults to every event of the source
-     * (`created` / `updated` / `removed`) when omitted.
-     */
-    readonly on?: readonly ('created' | 'updated' | 'removed')[];
-    /**
-     * Optional projection of the source payload into the sink record (target
-     * attribute → identity shorthand / transform). When omitted the whole source
-     * `newImage` is projected.
-     */
-    readonly fields?: Readonly<Record<string, ProjectionEntry>>;
-}
-/**
- * The IR for one `defineProjection` node — a stream + idempotency projection of a
- * source entity into an external sink. Consumed by the projection sink runtime
- * ({@link import('../cdc/projection-sink.js')}), which subscribes to
- * the CDC stream and upserts the projected record into the sink, folding
- * at-least-once delivery by {@link idempotencyKey}.
- */
-interface ProjectionDefinition {
-    readonly [PROJECTION_DEFINITION_MARKER]: true;
-    /** The projection's logical name (e.g. `'TestCaseResultBQ'`). */
-    readonly name: string;
-    /** The maintenance preset (always `'externalProjection'`). */
-    readonly pattern: 'externalProjection';
-    /** The resolved source model class whose events are projected. */
-    readonly sourceClass: AnyModelClass;
-    /** The transport (`'stream'`). */
-    readonly via: ProjectionVia;
-    /** The source attribute used as the idempotency key at the sink. */
-    readonly idempotencyKey: string;
-    /** The lifecycle events projected (defaults to all three). */
-    readonly on: readonly ('created' | 'updated' | 'removed')[];
-    /** The optional projection map (target attribute → transform IR); empty = whole image. */
-    readonly project: ProjectionMap;
+    readonly updateMode?: 'mutation' | 'stream';
+    readonly consistency?: 'transactional' | 'eventual';
 }
-/** Runtime guard: is `value` a {@link ProjectionDefinition}? */
-declare function isProjectionDefinition(value: unknown): value is ProjectionDefinition;
 /**
- * Define a single **external projection** (`externalProjection`, issue #132): a
- * stream + idempotency projection of a source entity into an external sink
- * (BigQuery / S3 / OpenSearch in production; the CDC emulator + an in-process sink
- * in dev/test). At-least-once delivery is folded to one sink upsert per genuine
- * source event by the {@link ProjectionDefinitionInput.idempotencyKey}.
+ * Build every {@link ViewDefinition} for a registry — from `@model({ kind })` +
+ * `@maintainedFrom` view models AND from versioned-pattern relations. This is the
+ * adapter the maintenance graph calls in place of the deleted `ViewRegistry.getAll()`.
  *
- * @example
- * ```ts
- * const TestCaseResultBQ = defineProjection('TestCaseResultBQ', {
- *   pattern: 'externalProjection',
- *   source: () => TestCaseResultModel,
- *   via: 'stream',
- *   idempotencyKey: 'resultId',
- * });
- * ```
- */
-declare function defineProjection(name: string, input: ProjectionDefinitionInput): ProjectionDefinition;
-/** A record of projection-name → {@link ProjectionDefinition}. */
-type ProjectionDefinitionMap = Record<string, ProjectionDefinition>;
-/**
- * Group a record of {@link defineProjection} nodes into the projection IR consumed
- * by the projection sink runtime. Validates every entry is a `defineProjection`
- * node — the `defineQueries`/`defineCommands` 様式.
+ * @param registry The models to scan. Defaults to `MetadataRegistry.getAll()`.
  */
-declare function defineProjections<const D extends ProjectionDefinitionMap>(definitions: D): D;
+declare function collectViewDefinitions(registry?: ReadonlyMap<Function, EntityMetadata>): ViewDefinition[];
 
 /**
  * Maintenance graph builder (Epic #118 issue #124 — the RFC B-案 core).
@@ -3387,6 +3079,13 @@ interface ManifestField {
      * mirroring the TS hydrator's `format`-driven `Date` reconstruction.
      */
     readonly format?: 'datetime' | 'date';
+    /**
+     * Optional human-readable description of the field (issue #154), from a field
+     * decorator option (`@string({ description })`). Pure documentation — absent
+     * unless declared, so a field with no description serializes byte-identically
+     * to the pre-#154 manifest. Surfaces as a field comment in the generated Python.
+     */
+    readonly description?: string;
 }
 /** A key (PK or GSI) template descriptor in the manifest. */
 interface ManifestKey {
@@ -3420,6 +3119,13 @@ interface ManifestEntity {
     readonly key: ManifestKey | null;
     readonly gsis: readonly ManifestGsi[];
     readonly relations: Readonly<Record<string, ManifestRelation>>;
+    /**
+     * Optional human-readable description of the entity (issue #154), from
+     * `@model({ description })`. Pure documentation — absent unless declared, so an
+     * entity with no description serializes byte-identically to the pre-#154
+     * manifest. Surfaces as the generated Python class docstring.
+     */
+    readonly description?: string;
 }
 interface ManifestTable {
     readonly physicalName: string;
@@ -3439,6 +3145,13 @@ interface ParamSpec {
      * descriptors (field name → element param spec). Omitted for scalar params.
      */
     readonly element?: Readonly<Record<string, ParamSpec>>;
+    /**
+     * Optional human-readable description of the parameter (issue #154), from a
+     * `param.*({ description })` placeholder. Pure documentation — absent unless
+     * declared, so a param with no description serializes byte-identically to the
+     * pre-#154 spec. The Python runtime never reads it for execution.
+     */
+    readonly description?: string;
 }
 /** A `begins_with` range condition on a sort key (templated value). */
 interface RangeConditionSpec {
@@ -3547,6 +3260,13 @@ interface QuerySpec {
      * backward-compatible (plan-absent → sequential) fallback.
      */
     readonly executionPlan?: ExecutionPlanSpec;
+    /**
+     * Optional human-readable description of the query (issue #154), from
+     * `defineQuery(..., { description })`. Pure documentation — absent unless
+     * declared, so a query with no description serializes byte-identically to the
+     * pre-#154 spec. Surfaces as the generated Python repository-method docstring.
+     */
+    readonly description?: string;
 }
 type WriteOperationType = 'PutItem' | 'UpdateItem' | 'DeleteItem';
 /**
@@ -3624,6 +3344,14 @@ interface CommandSpec {
     readonly changes?: Readonly<Record<string, string>>;
     /** Optional write condition (subset). */
     readonly condition?: ConditionSpec;
+    /**
+     * Optional human-readable description of the command (issue #154), from
+     * `definePut`/`defineUpdate`/`defineDelete(..., { description })`. Pure
+     * documentation — absent unless declared, so a command with no description
+     * serializes byte-identically to the pre-#154 spec. Surfaces as the generated
+     * Python repository-method docstring.
+     */
+    readonly description?: string;
 }
 /**
  * A declarative `when` guard on a transaction item (issue #46). Compares a
@@ -3974,6 +3702,14 @@ interface QueryContractMethodSpec {
      * call (chunk ≤100). Absent → resolve compositions sequentially (pre-#70).
      */
     readonly compositionPlan?: CompositionPlanSpec;
+    /**
+     * Optional human-readable description of the read use case (issue #154), from the
+     * descriptor's `description`. Pure documentation — absent unless declared, so a
+     * method with no description serializes byte-identically to the pre-#154 spec.
+     * The same string appears in the TS contract IR and (via the SSoT) in any
+     * generated binding, so TS↔Python carry an identical description.
+     */
+    readonly description?: string;
 }
 /**
  * How a contract command method resolves a single key vs. an array of keys to the
@@ -4040,6 +3776,12 @@ interface CommandContractMethodSpec {
      * {@link result} stays `'void'` / `'entity'` and it returns no projected item).
      */
     readonly returnSelection?: Readonly<Record<string, boolean>>;
+    /**
+     * Optional human-readable description of the write use case (issue #154), from
+     * the descriptor's `description`. Pure documentation — absent unless declared, so
+     * a method with no description serializes byte-identically to the pre-#154 spec.
+     */
+    readonly description?: string;
 }
 /**
  * A serialized contract — a keyed public read (`'query'`) or write (`'command'`)
@@ -5085,6 +4827,13 @@ interface ContractMethodOp<Op extends OperationKind = OperationKind> {
      * when the body declares no composition.
      */
     readonly compose?: readonly RecordedCompose[];
+    /**
+     * Optional human-readable description of the use case (issue #154), captured from
+     * the descriptor's `description`. Pure documentation — carried on the op so the
+     * serializer can emit it onto the contract method spec; it never affects the
+     * recorded operation, key, or runtime behaviour.
+     */
+    readonly description?: string;
 }
 /**
  * A recorded External Query composition edge on a contract method op (#63). The
@@ -5167,6 +4916,12 @@ interface QueryMethodSpec<TKey, TParams, TResult, A extends InputArity = InputAr
      * the referenced contract name by identity ({@link contractOfMethodSpec}).
      */
     readonly __methodName?: string;
+    /**
+     * Optional human-readable description of the use case (issue #154), from the
+     * descriptor's `description`. Pure documentation — propagated to the serialized
+     * {@link import('../spec/types.js').QueryContractMethodSpec.description}.
+     */
+    readonly description?: string;
     /** @internal Phantom carrier retaining the formal `QueryMethod` type. */
     readonly __signature?: QueryMethod<TKey, TParams, TResult>;
 }
@@ -5319,6 +5074,12 @@ interface CommandMethodSpec<TKey, TParams, TResult> {
      * at least one stream maintainer; absent otherwise (no regression).
      */
     readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
+    /**
+     * Optional human-readable description of the write use case (issue #154), from
+     * the descriptor's `description`. Pure documentation — propagated to the
+     * serialized {@link import('../spec/types.js').CommandContractMethodSpec.description}.
+     */
+    readonly description?: string;
     /** @internal Phantom carrier retaining the formal `CommandMethod` type. */
     readonly __signature?: CommandMethod<TKey, TParams, TResult>;
 }
@@ -5521,6 +5282,13 @@ interface PublicReadDescriptor {
     readonly key: Readonly<Record<string, unknown>>;
     readonly select: Readonly<Record<string, unknown>>;
     readonly options?: Readonly<Record<string, unknown>>;
+    /**
+     * Optional human-readable description of the read use case (issue #154). Pure
+     * documentation — propagated to the serialized {@link
+     * import('../spec/types.js').QueryContractMethodSpec.description} in
+     * `operations.json`. Omit for unchanged output.
+     */
+    readonly description?: string;
 }
 /** A public **write** descriptor (issue #101): `{ create | update | remove: Model, key, input?, condition?, result?, mode? }`. */
 interface PublicWriteDescriptor {
@@ -5535,6 +5303,13 @@ interface PublicWriteDescriptor {
         readonly options?: unknown;
     };
     readonly mode?: CommandMode;
+    /**
+     * Optional human-readable description of the write use case (issue #154). Pure
+     * documentation — propagated to the serialized {@link
+     * import('../spec/types.js').CommandContractMethodSpec.description} in
+     * `operations.json`. Omit for unchanged output.
+     */
+    readonly description?: string;
 }
 /**
  * A public **composite write** descriptor (issue #101) — the closure-free twin of
@@ -5552,6 +5327,12 @@ interface PublicComposeDescriptor {
         readonly options?: unknown;
     };
     readonly mode?: CommandMode;
+    /**
+     * Optional human-readable description of the composite write use case (issue
+     * #154). Pure documentation — propagated to the serialized {@link
+     * import('../spec/types.js').CommandContractMethodSpec.description}.
+     */
+    readonly description?: string;
 }
 
 /**
@@ -6424,6 +6205,15 @@ interface FieldOptions {
     readonly?: boolean;
     serialize?: (value: unknown) => unknown;
     deserialize?: (value: unknown) => unknown;
+    /**
+     * Optional human-readable description of the field (issue #154). Pure
+     * documentation metadata — it does NOT affect storage, hydration, key handling,
+     * or any runtime behaviour. When present it is propagated to the field entry in
+     * `manifest.json` ({@link ManifestField.description}) and surfaces as a field
+     * comment in the generated Python `types.py`. Absent → byte-for-byte unchanged
+     * output (backward compatible).
+     */
+    description?: string;
 }
 interface FieldMetadata {
     propertyName: string;
@@ -6442,6 +6232,49 @@ interface FieldMetadata {
     literals?: readonly string[];
 }
 
+/**
+ * The maintenance kind of a model (issue #152). `'entity'` (the default) is a plain
+ * stored entity. `'materializedView'` / `'sparseView'` mark a model as a maintained
+ * **view** row whose `@maintainedFrom` declarations feed the maintenance graph (the
+ * adapter that replaces the old `defineView` / `ViewRegistry` path). A `sparseView`
+ * requires every `@maintainedFrom` to carry a `when` membership predicate.
+ */
+type ModelKind = 'entity' | 'materializedView' | 'sparseView';
+/**
+ * One lowered `@maintainedFrom(source, (self, source) => options)` declaration on a
+ * view model (issue #152). It is the decorator-declarative replacement for one
+ * `defineView` source slice: the symbolic `(self, source) =>` callback has already
+ * been evaluated into the SAME payload-rooted IR (`keyBind` → `$.entity.*` key
+ * binding, `project` → {@link ProjectionMap}), so the adapter
+ * (`src/relation/maintenance-view-adapter.ts`) reconstructs a byte-identical
+ * `ViewSourceSlice` from it.
+ *
+ * `collection` and `when` are mutually exclusive (a row either holds a maintained
+ * list or appears/disappears as a whole — the same rule the old builder enforced).
+ */
+interface MaintainedFromMetadata {
+    /** Resolves the source entity whose lifecycle events maintain the view row. */
+    sourceFactory: () => new (...args: unknown[]) => unknown;
+    /** The lifecycle events that maintain the view row (`created`/`updated`/`removed`). */
+    on: readonly MaintainEvent[];
+    /** The view-row key binding (view-row key field → payload-rooted source value). */
+    keyBind: Readonly<Record<string, EffectPath>>;
+    /** The projection of the source payload into the view row (target attr → transform). */
+    project: ProjectionMap;
+    /** Bounded/ordered collection options when this declaration maintains a list. */
+    collection?: {
+        /** The view-row attribute that holds the maintained list (a `self.<field>`). */
+        field: string;
+        maxItems?: number;
+        order?: 'ASC' | 'DESC';
+        /** The source value the collection orders by / trims on (`$.entity.<field>`). */
+        orderBy?: EffectPath;
+    };
+    /** Sparse-view membership predicate (mutually exclusive with `collection`). */
+    when?: MembershipPredicate;
+    consistency?: MaintainConsistency;
+    updateMode?: MaintainUpdateMode;
+}
 interface KeyDefinition {
     /** The canonical structured key (PK/SK segment lists). */
     segmented: SegmentedKey;
@@ -6471,8 +6304,18 @@ interface RelationLimitOptions {
  * Typed as a `string` union of the known presets but kept open-ended via the
  * `(string & {})` tail so a future preset can be authored before this union is
  * widened, without a breaking change to callers.
+ *
+ * The union lists only the presets that are actually *reachable* as a recorded
+ * `RelationOptions.pattern` / `AggregateOptions.pattern` value: `samePartition`,
+ * `counter`, `embeddedSnapshot`, and the two versioned discriminators
+ * `versionedLatest` / `versionedHistory` (issue #152). `materializedView` /
+ * `sparseView` migrated to the model-level `@model({ kind })` selector (they are
+ * a {@link ModelKind}, not a relation preset); the placeholder `edge` /
+ * `dualEdge` / `versioned` / `externalProjection` names are not authored anywhere
+ * and were removed. A future preset can still be written against the `(string & {})`
+ * tail before it is added to this union.
  */
-type RelationPattern = 'samePartition' | 'edge' | 'dualEdge' | 'counter' | 'embeddedSnapshot' | 'materializedView' | 'sparseView' | 'versioned' | 'externalProjection' | (string & {});
+type RelationPattern = 'samePartition' | 'counter' | 'embeddedSnapshot' | 'versionedLatest' | 'versionedHistory' | (string & {});
 /**
  * Consistency boundary a maintained write is declared against (Epic #118 §4.A.7):
  * `transactional` = same `TransactWriteItems`; `eventual` = asynchronous catch-up.
@@ -6549,6 +6392,23 @@ interface RelationOptions {
     read?: RelationReadOptions;
     write?: RelationWriteOptions;
     projection?: RelationProjection;
+    /**
+     * Lowered versioned-pattern declaration (issue #152, section B). Present only when
+     * the relation declares `pattern: 'versionedLatest' | 'versionedHistory'` via the
+     * `@hasOne/@hasMany(() => Target, (self, source) => ({...}))` callback form. The
+     * declaring model is the SOURCE (a revision); the relation target is the
+     * DESTINATION view row. The adapter
+     * (`src/relation/maintenance-view-adapter.ts`) lowers this to the SAME `defineView`
+     * snapshot IR the old `defineVersioned` produced (latest = overwrite, history =
+     * append). `on` are the lifecycle events; `project` is the lowered projection map.
+     */
+    versioned?: {
+        readonly mode: 'latest' | 'history';
+        readonly on: readonly MaintainEvent[];
+        readonly project: ProjectionMap;
+        readonly consistency?: MaintainConsistency;
+        readonly updateMode?: MaintainUpdateMode;
+    };
 }
 interface RelationMetadata {
     type: 'hasMany' | 'hasOne' | 'belongsTo';
@@ -6646,6 +6506,30 @@ interface EntityMetadata {
     /** Scalar `@aggregate` fields (Epic #118 §5.2 counter / latest; issue #122). */
     aggregates: AggregateMetadata[];
     embeddedFields: EmbeddedMetadata[];
+    /**
+     * The model's maintenance kind (issue #152). `'entity'` (default; also assumed
+     * when absent, for hand-built metadata in tests) is a plain stored entity;
+     * `'materializedView'` / `'sparseView'` mark it a maintained view row fed by
+     * {@link maintainedFrom}.
+     */
+    kind?: ModelKind;
+    /**
+     * Optional human-readable description of the entity (issue #154), supplied via
+     * `@model({ description })`. Pure documentation metadata — it does NOT affect
+     * storage, keys, or any runtime behaviour. When present it is propagated to the
+     * entity entry in `manifest.json` ({@link ManifestEntity.description}) and
+     * surfaces as the class docstring in the generated Python `types.py`. Absent →
+     * byte-for-byte unchanged output (backward compatible).
+     */
+    description?: string;
+    /**
+     * Class-level `@maintainedFrom(...)` declarations (issue #152). Non-empty only on
+     * a `materializedView` / `sparseView` model; each is one source slice the view
+     * row is maintained from. The adapter lowers these to the maintenance graph's
+     * `ViewDefinition` IR (replacing the old `defineView` / `ViewRegistry` path).
+     * Absent / empty for a plain entity.
+     */
+    maintainedFrom?: MaintainedFromMetadata[];
 }
 
 /**
@@ -6761,4 +6645,4 @@ interface CdcEmulatorOptions {
 }
 type ShardId = string;
 
-export { type RelationMetadata as $, type AggregateOptions as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FieldOptions as F, type GsiDefinition as G, type ResolvedKey as H, type Item as I, type CdcEmulatorOptions as J, type KeyDefinition as K, type ChangeHandler as L, type ModelStatic as M, type Unsubscribe as N, type FaultSpec as O, type PutInput as P, type ConcurrentRecomputeRef as Q, type ReadExecOptions as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type EventLog as V, type WriteExecOptions as W, type ReplayOptions as X, type ShardId as Y, type ViewDefinition as Z, type ProjectionDefinition as _, type ExecutorResult as a, type ContractKeyFieldRef as a$, type TransactionItemSpec as a0, type MaintainEffect as a1, type Param as a2, type ParamDescriptor as a3, type DefinitionMap as a4, type OperationDefinition as a5, type WriteDefinitionOptions as a6, type PartialQueryKeyOf as a7, type StrictSelectSpec as a8, type EntityInput as a9, type ChangeBatch as aA, type ChangeEventName as aB, type ClockMode as aC, type CollectionEffect as aD, type CollectionOptions as aE, type Column as aF, type ColumnMap as aG, type CommandContractMethodSpec as aH, type CommandInputShape as aI, type CommandMethod as aJ, type CommandPlan as aK, type CommandResolutionTarget as aL, type CommandResultKind as aM, type CommandSelectShape as aN, type CompiledFragment as aO, type ComposeSpec as aP, type CondSlot as aQ, type ConditionCheckInput as aR, type Connection as aS, type ContractCallSignature as aT, type ContractCardinality as aU, type ContractCommandParams as aV, type ContractCommandResult as aW, type ContractComposeNode as aX, type ContractFromRef as aY, type ContractInputArity as aZ, type ContractItem as a_, type UniqueQueryKeyOf as aa, type EntityRef as ab, type ConditionInput as ac, type QueryModelContract as ad, type QueryMethodSpec as ae, type CommandModelContract as af, type CommandMethodSpec as ag, type ContractSpec as ah, type QuerySpec as ai, type CommandSpec as aj, type ContextSpec as ak, type OperationsDocument as al, type AnyOperationDefinition as am, type BridgeBundle as an, type ConditionSpec as ao, type AggregateMetadata as ap, type BatchDeleteRequest as aq, type BatchGetOptions as ar, type BatchGetRequest as as, BatchGetResult as at, type BatchPutRequest as au, type BatchResult as av, type BatchWriteRequest as aw, CONTRACT_RANGE_FANOUT_CONCURRENCY as ax, type CdcMode as ay, type Change as az, type WriteResult as b, type MutateParallelResult as b$, type ContractKeyInput as b0, type ContractKeyRef as b1, type ContractKeySpec as b2, type ContractKind as b3, type ContractMethodOp as b4, type ContractParamRef as b5, type ContractQueryParams as b6, type ContractResolution as b7, type CounterAggregate as b8, type CounterEffect as b9, type KeySegment as bA, type KeySlot as bB, type KeyStructure as bC, type KeyedResult as bD, LIFECYCLE_CONTRACT_MARKER as bE, type LifecycleContract as bF, type LifecycleEffects as bG, type LiteralParam as bH, type MaintainConsistency as bI, type MaintainEvent as bJ, type MaintainItem as bK, type MaintainTrigger as bL, type MaintainUpdateMode as bM, type MaintenanceGraph as bN, type ManifestEntity as bO, type ManifestField as bP, type ManifestFieldType as bQ, type ManifestGsi as bR, type ManifestKey as bS, type ManifestRelation as bT, type ManifestTable as bU, type MembershipEffect as bV, type MembershipPredicate as bW, type MembershipPredicateOp as bX, type ModelRef as bY, type MutateMode as bZ, type MutateOptions as b_, type CtxBase as ba, DEFAULT_MAX_ATTEMPTS as bb, DEFAULT_RETRY_POLICY as bc, type DeleteOptions as bd, type DeriveEffect as be, type DerivedEdgeWrite as bf, type DerivedUpdate as bg, type DescriptorBinding as bh, ENTITY_WRITES_MARKER as bi, type EdgeEffect as bj, type EffectPath as bk, type EmbeddedMetadata as bl, type EmitEffect as bm, type EntityWritesDefinition as bn, type EntityWritesShape as bo, type ExecutableCommandContract as bp, type ExecutableQueryContract as bq, type FilterInput as br, type FilterSpec as bs, type FragmentInput as bt, type GsiDefinitionMarker as bu, type GsiOptions as bv, type IdempotencyEffect as bw, type InProcessWriteDescriptor as bx, type InputArity as by, type KeyDefinitionMarker as bz, type DeleteInput as c, type UniqueEffect as c$, type MutateTransactionResult as c0, type MutationBody as c1, type MutationDescriptorMap as c2, type MutationFragment as c3, type MutationInputProxy as c4, type MutationInputRef as c5, type MutationIntent as c6, type NumberParam as c7, type OperationKind as c8, type OperationSpec as c9, type ReadRouteResult as cA, type RecordedCompose as cB, type RelationBuilder as cC, type RelationConsistency as cD, type RelationLimitOptions as cE, type RelationPattern as cF, type RelationProjection as cG, type RelationReadOptions as cH, type RelationSelect as cI, type RelationSpec as cJ, type RelationUpdateMode as cK, type RelationWriteOptions as cL, type RequiresEffect as cM, type Resolution as cN, type RetryInfo as cO, type RetryOperationKind as cP, SPEC_VERSION as cQ, type SegmentSpec as cR, type SegmentedKey as cS, type SelectBuilder as cT, type SelectOf as cU, type SnapshotEffect as cV, type StartingPosition as cW, type StreamViewType as cX, type StringParam as cY, TransactionContext as cZ, type TransactionItemType as c_, type ParallelOpResult as ca, type ParamKind as cb, type ParamSpec as cc, type ParamStructure as cd, type PersistCtx as ce, type PersistOrigin as cf, type PlannedCommandMethod as cg, type ProjectionDefinitionInput as ch, type ProjectionDefinitionMap as ci, type ProjectionMap as cj, type ProjectionTransform as ck, type ProjectionTransformOp as cl, type ProjectionVia as cm, type PutOptions as cn, type QueryContractMethodSpec as co, type QueryEnvelopeResult as cp, type QueryKeyOf as cq, type QueryMethod as cr, type QueryResult as cs, type RangeConditionSpec as ct, type ReadEnvelope as cu, type ReadOpCtx as cv, type ReadOpKind as cw, type ReadOperationType as cx, type ReadRouteDescriptor as cy, type ReadRouteOptions as cz, type BatchWriteExecItem as d, isMaintainTrigger as d$, type Updatable as d0, type UpdateOptions as d1, type VersionedDefinition as d2, type VersionedDefinitionInput as d3, type ViewDefinitionInput as d4, type ViewDefinitionMap as d5, ViewRegistry as d6, type ViewSource as d7, type ViewSourceSlice as d8, type WhenSpec as d9, defineViews as dA, entityWrites as dB, executeBatchGet as dC, executeBatchWrite as dD, executeCommandMethod as dE, executeDelete as dF, executeKeyedBatchGet as dG, executePut as dH, executeQueryMethod as dI, executeRangeFanout as dJ, executeTransaction as dK, executeUpdate as dL, from as dM, getEntityWrites as dN, gsi as dO, identity as dP, isColumn as dQ, isCommandModelContract as dR, isCommandPlan as dS, isContractComposeNode as dT, isContractFromRef as dU, isContractKeyFieldRef as dV, isContractKeyRef as dW, isContractParamRef as dX, isEntityWritesDefinition as dY, isKeySegment as dZ, isLifecycleContract as d_, type WriteCtx as da, type WriteDescriptor as db, type WriteEnvelope as dc, type WriteInput as dd, type WriteKind as de, type WriteLifecyclePhase as df, type WriteMiddleware as dg, type WriteOperationType as dh, type WriteRecorder as di, type WriteResultProjection as dj, attachModelClass as dk, buildDeleteInput as dl, buildMaintenanceGraph as dm, buildPutInput as dn, buildUpdateInput as dp, compileFragment as dq, compileMutationPlan as dr, compileSingleFragmentPlan as ds, cond as dt, contractOfMethodSpec as du, definePlan as dv, defineProjection as dw, defineProjections as dx, defineVersioned as dy, defineView as dz, type BatchExecOptions as e, isMutationFragment as e0, isMutationInputRef as e1, isParam as e2, isPlannedCommandMethod as e3, isProjectionDefinition as e4, isQueryModelContract as e5, isRetryableError as e6, isRetryableTransactionCancellation as e7, isViewDefinition as e8, k as e9, key as ea, lifecyclePhaseForIntent as eb, maintainTrigger as ec, mintContractKeyFieldRef as ed, mintContractParamRef as ee, mutation as ef, param as eg, preview as eh, publicCommandModel as ei, publicQueryModel as ej, query as ek, resolveLifecycle as el, whenMember as em, wholeKeysSentinel as en, DDBModel as f, type PrimaryKeyOf as g, type RequestContext as h, type Middleware as i, type ReadRequestKind as j, type CtxModel as k, type ReadParams as l, type ReadRequestCtx as m, type RetryPolicy as n, type ExecutionPlanSpec as o, type EntityMetadata as p, type DynamoType as q, type RelationOptions as r, type AggregateValue as s, type SelectBuilderSpec as t, type RawCondition as u, type TransactionSpec as v, type Manifest as w, type RetryOverride as x, type ExecutionPlan as y, type FieldMetadata as z };
+export { type FaultSpec as $, type AggregateOptions as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FieldOptions as F, type GsiDefinition as G, type SelectBuilderSpec as H, type Item as I, type RawCondition as J, type KeyDefinition as K, type TransactionSpec as L, type ModelStatic as M, type Manifest as N, type RetryOverride as O, type PutInput as P, type ExecutionPlan as Q, type ReadExecOptions as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type FieldMetadata as V, type WriteExecOptions as W, type ResolvedKey as X, type CdcEmulatorOptions as Y, type ChangeHandler as Z, type Unsubscribe as _, type ExecutorResult as a, type ContractCardinality as a$, type ConcurrentRecomputeRef as a0, type EventLog as a1, type ReplayOptions as a2, type ShardId as a3, type ViewDefinition as a4, type RelationMetadata as a5, type TransactionItemSpec as a6, type MaintainEffect as a7, type Param as a8, type ParamDescriptor as a9, BatchGetResult as aA, type BatchPutRequest as aB, type BatchResult as aC, type BatchWriteRequest as aD, CONTRACT_RANGE_FANOUT_CONCURRENCY as aE, type CdcMode as aF, type Change as aG, type ChangeBatch as aH, type ChangeEventName as aI, type ClockMode as aJ, type CollectionEffect as aK, type CollectionOptions as aL, type Column as aM, type ColumnMap as aN, type CommandContractMethodSpec as aO, type CommandInputShape as aP, type CommandMethod as aQ, type CommandPlan as aR, type CommandResolutionTarget as aS, type CommandResultKind as aT, type CommandSelectShape as aU, type CompiledFragment as aV, type ComposeSpec as aW, type CondSlot as aX, type ConditionCheckInput as aY, type Connection as aZ, type ContractCallSignature as a_, type DefinitionMap as aa, type OperationDefinition as ab, type WriteDefinitionOptions as ac, type PartialQueryKeyOf as ad, type StrictSelectSpec as ae, type ReadDefinitionOptions as af, type EntityInput as ag, type UniqueQueryKeyOf as ah, type EntityRef as ai, type ConditionInput as aj, type QueryModelContract as ak, type QueryMethodSpec as al, type CommandModelContract as am, type CommandMethodSpec as an, type ContractSpec as ao, type QuerySpec as ap, type CommandSpec as aq, type ContextSpec as ar, type OperationsDocument as as, type AnyOperationDefinition as at, type BridgeBundle as au, type ConditionSpec as av, type AggregateMetadata as aw, type BatchDeleteRequest as ax, type BatchGetOptions as ay, type BatchGetRequest as az, type WriteResult as b, type MutateMode as b$, type ContractCommandParams as b0, type ContractCommandResult as b1, type ContractComposeNode as b2, type ContractFromRef as b3, type ContractInputArity as b4, type ContractItem as b5, type ContractKeyFieldRef as b6, type ContractKeyInput as b7, type ContractKeyRef as b8, type ContractKeySpec as b9, type FragmentInput as bA, type GsiDefinitionMarker as bB, type GsiOptions as bC, type IdempotencyEffect as bD, type InProcessWriteDescriptor as bE, type InputArity as bF, type KeyDefinitionMarker as bG, type KeySegment as bH, type KeySlot as bI, type KeyStructure as bJ, type KeyedResult as bK, LIFECYCLE_CONTRACT_MARKER as bL, type LifecycleContract as bM, type LifecycleEffects as bN, type LiteralParam as bO, type MaintainItem as bP, type MaintainTrigger as bQ, type MaintenanceGraph as bR, type ManifestEntity as bS, type ManifestField as bT, type ManifestFieldType as bU, type ManifestGsi as bV, type ManifestKey as bW, type ManifestRelation as bX, type ManifestTable as bY, type MembershipEffect as bZ, type ModelRef as b_, type ContractKind as ba, type ContractMethodOp as bb, type ContractParamRef as bc, type ContractQueryParams as bd, type ContractResolution as be, type CounterAggregate as bf, type CounterEffect as bg, type CtxBase as bh, DEFAULT_MAX_ATTEMPTS as bi, DEFAULT_RETRY_POLICY as bj, type DeleteOptions as bk, type DeriveEffect as bl, type DerivedEdgeWrite as bm, type DerivedUpdate as bn, type DescriptorBinding as bo, ENTITY_WRITES_MARKER as bp, type EdgeEffect as bq, type EffectPath as br, type EmbeddedMetadata as bs, type EmitEffect as bt, type EntityWritesDefinition as bu, type EntityWritesShape as bv, type ExecutableCommandContract as bw, type ExecutableQueryContract as bx, type FilterInput as by, type FilterSpec as bz, type DeleteInput as c, type UpdateOptions as c$, type MutateOptions as c0, type MutateParallelResult as c1, type MutateTransactionResult as c2, type MutationBody as c3, type MutationDescriptorMap as c4, type MutationFragment as c5, type MutationInputProxy as c6, type MutationInputRef as c7, type MutationIntent as c8, type NumberParam as c9, type RelationBuilder as cA, type RelationConsistency as cB, type RelationLimitOptions as cC, type RelationPattern as cD, type RelationProjection as cE, type RelationReadOptions as cF, type RelationSelect as cG, type RelationSpec as cH, type RelationUpdateMode as cI, type RelationWriteOptions as cJ, type RequiresEffect as cK, type Resolution as cL, type RetryInfo as cM, type RetryOperationKind as cN, SPEC_VERSION as cO, type SegmentSpec as cP, type SegmentedKey as cQ, type SelectBuilder as cR, type SelectOf as cS, type SnapshotEffect as cT, type StartingPosition as cU, type StreamViewType as cV, type StringParam as cW, TransactionContext as cX, type TransactionItemType as cY, type UniqueEffect as cZ, type Updatable as c_, type OperationKind as ca, type OperationSpec as cb, type ParallelOpResult as cc, type ParamKind as cd, type ParamSpec as ce, type ParamStructure as cf, type PersistCtx as cg, type PersistOrigin as ch, type PlannedCommandMethod as ci, type ProjectionMap as cj, type ProjectionTransformOp as ck, type PutOptions as cl, type QueryContractMethodSpec as cm, type QueryEnvelopeResult as cn, type QueryKeyOf as co, type QueryMethod as cp, type QueryResult as cq, type RangeConditionSpec as cr, type ReadEnvelope as cs, type ReadOpCtx as ct, type ReadOpKind as cu, type ReadOperationType as cv, type ReadRouteDescriptor as cw, type ReadRouteOptions as cx, type ReadRouteResult as cy, type RecordedCompose as cz, type BatchWriteExecItem as d, mintContractKeyFieldRef as d$, type ViewSourceSlice as d0, type WhenSpec as d1, type WriteCtx as d2, type WriteDescriptor as d3, type WriteEnvelope as d4, type WriteInput as d5, type WriteKind as d6, type WriteLifecyclePhase as d7, type WriteMiddleware as d8, type WriteOperationType as d9, from as dA, getEntityWrites as dB, gsi as dC, identity as dD, isColumn as dE, isCommandModelContract as dF, isCommandPlan as dG, isContractComposeNode as dH, isContractFromRef as dI, isContractKeyFieldRef as dJ, isContractKeyRef as dK, isContractParamRef as dL, isEntityWritesDefinition as dM, isKeySegment as dN, isLifecycleContract as dO, isMaintainTrigger as dP, isMutationFragment as dQ, isMutationInputRef as dR, isParam as dS, isPlannedCommandMethod as dT, isQueryModelContract as dU, isRetryableError as dV, isRetryableTransactionCancellation as dW, k as dX, key as dY, lifecyclePhaseForIntent as dZ, maintainTrigger as d_, type WriteRecorder as da, type WriteResultProjection as db, attachModelClass as dc, buildDeleteInput as dd, buildMaintenanceGraph as de, buildPutInput as df, buildUpdateInput as dg, collectViewDefinitions as dh, compileFragment as di, compileMutationPlan as dj, compileSingleFragmentPlan as dk, cond as dl, contractOfMethodSpec as dm, definePlan as dn, entityWrites as dp, executeBatchGet as dq, executeBatchWrite as dr, executeCommandMethod as ds, executeDelete as dt, executeKeyedBatchGet as du, executePut as dv, executeQueryMethod as dw, executeRangeFanout as dx, executeTransaction as dy, executeUpdate as dz, type BatchExecOptions as e, mintContractParamRef as e0, mutation as e1, param as e2, preview as e3, publicCommandModel as e4, publicQueryModel as e5, query as e6, resolveLifecycle as e7, wholeKeysSentinel as e8, DDBModel as f, type PrimaryKeyOf as g, type RequestContext as h, type Middleware as i, type ReadRequestKind as j, type CtxModel as k, type ReadParams as l, type ReadRequestCtx as m, type RetryPolicy as n, type ExecutionPlanSpec as o, type EntityMetadata as p, type ModelKind as q, type DynamoType as r, type ProjectionTransform as s, type MaintainEvent as t, type MembershipPredicate as u, type MaintainConsistency as v, type MaintainUpdateMode as w, type MembershipPredicateOp as x, type RelationOptions as y, type AggregateValue as z };