graphddb 0.3.0 → 0.4.0

package/dist/{types-xJRn5qkv.d.ts → types-CpCo8yHP.d.ts}

@@ -1343,7 +1343,7 @@ type ProjectionOf<T, Sel> = Sel extends SelectableOf<T> ? Sel : SelectOf<Sel>;
  * usages keep compiling, while the precise inference is available when the
  * constructor type is supplied (as it is from `DDBModel.asModel()`).
  */
-type AnyModelClass = abstract new (...args: any[]) => DDBModel;
+type AnyModelClass$1 = abstract new (...args: any[]) => DDBModel;
 /**
  * The accepted PK / GSI key type for `list()` / `explain()`.
  *
@@ -1353,24 +1353,24 @@ type AnyModelClass = abstract new (...args: any[]) => DDBModel;
  * {@link QueryKey}. Derived from the model class when available, otherwise
  * permissive.
  */
-type ListKey<C> = [C] extends [AnyModelClass] ? PartialQueryKeyOf<C> : Record<string, unknown>;
+type ListKey<C> = [C] extends [AnyModelClass$1] ? PartialQueryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted key type for `query()` — only keys guaranteed to return a
  * single item (PK + unique GSIs). Derived from the model class when available.
  */
-type QueryKey<C> = [C] extends [AnyModelClass] ? UniqueQueryKeyOf<C> : Record<string, unknown>;
+type QueryKey<C> = [C] extends [AnyModelClass$1] ? UniqueQueryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted key type for `delete()` (PK only). Derived from the model
  * class when available.
  */
-type DeleteKey<C> = [C] extends [AnyModelClass] ? PrimaryKeyOf<C> : Record<string, unknown>;
+type DeleteKey<C> = [C] extends [AnyModelClass$1] ? PrimaryKeyOf<C> : Record<string, unknown>;
 /**
  * The accepted *explicit* key type for `update()` — the base-table primary key
  * only. DynamoDB `UpdateItem` can target an item solely by its base-table PK
  * (GSI-based updates are impossible), so this is `PrimaryKeyOf<C>`, not
  * `UniqueQueryKeyOf<C>`. Derived from the model class when available.
  */
-type UpdateExplicitKey<C> = [C] extends [AnyModelClass] ? PrimaryKeyOf<C> : Record<string, unknown>;
+type UpdateExplicitKey<C> = [C] extends [AnyModelClass$1] ? PrimaryKeyOf<C> : Record<string, unknown>;
 /**
  * Options accepted by `list()` (third argument). The projection is supplied as
  * the separate second `select` argument, symmetric with `query()`.
@@ -2057,7 +2057,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 +2079,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
@@ -2115,19 +2125,33 @@ interface SnapshotEffect {
     /** The consistency the write lands under (default `eventual`). */
     readonly consistency?: MaintainConsistency;
 }
+/** The sort direction a maintained collection orders by (mirrors the read-side `read.order`). */
+type CollectionOrderDirection = 'ASC' | 'DESC';
 /**
  * Options for the bounded collection a {@link CollectionEffect} maintains: the
  * target {@link field} that holds the collection, an optional {@link maxItems}
  * cap (oldest items are evicted past it), and an optional {@link orderBy} source
- * path the items are ordered by.
+ * path the items are ordered by (with an {@link orderDir} direction).
  */
 interface CollectionOptions {
     /** The target attribute that holds the maintained collection. */
     readonly field: string;
     /** Cap on the collection size; items past it are evicted (unbounded if omitted). */
     readonly maxItems?: number;
-    /** A path-rooted source value the collection is ordered by (e.g. `$.entity.createdAt`). */
+    /**
+     * A path-rooted source value the collection is ordered by (e.g. `$.entity.createdAt`).
+     * Wired from the relation's `read.order` (#130 是正2): the field is the source
+     * entity's sort-key leaf (the field the live `hasMany` read orders by via
+     * `ScanIndexForward`), so the materialized collection sorts the SAME way as the
+     * live query. The async drain ({@link import('../cdc/maintenance-drain.js')})
+     * applies the sort + trim; a single synchronous `UpdateExpression` cannot.
+     */
     readonly orderBy?: EffectPath;
+    /**
+     * The direction {@link orderBy} sorts by — `'DESC'` (newest first, the default a
+     * bare `order: 'DESC'` declares) or `'ASC'`. Present only when {@link orderBy} is.
+     */
+    readonly orderDir?: CollectionOrderDirection;
 }
 /**
  * A **collection** maintenance effect (issue #120): on a {@link MaintainTrigger}
@@ -2216,12 +2240,81 @@ interface CounterEffect {
     /** The consistency the write lands under (default `eventual`). */
     readonly consistency?: MaintainConsistency;
 }
+/**
+ * The comparison op a {@link MembershipPredicate} applies to the source value
+ * (Epic #118 pattern 6 / sparse view, issue #133). The host-side drain evaluates
+ * the predicate against the source payload to decide PUT (true) vs DELETE (false):
+ *
+ * - `truthy` / `falsy` — the source value is/ isn't truthy (no `value`);
+ * - `exists` / `notExists` — the source attribute is present / absent (no `value`);
+ * - `eq` / `ne` — the source value equals / does not equal {@link MembershipPredicate.value}.
+ */
+type MembershipPredicateOp = 'truthy' | 'falsy' | 'exists' | 'notExists' | 'eq' | 'ne';
+/**
+ * A membership predicate over the source payload (Epic #118 pattern 6 / sparse view,
+ * issue #133). When the predicate holds, the view item is PUT (projected); when it
+ * flips false the view item is DELETED. This is the "述語が flip したら view item を
+ * put/delete" maintenance — distinct from a GSI sparse index (an explicit view row,
+ * conditionally present). The `path` is a payload-rooted source value (`$.entity.*` /
+ * `$.input.*`); `value` is the comparand for `eq` / `ne` (absent for the unary ops).
+ */
+interface MembershipPredicate {
+    /** The payload-rooted source value the predicate tests (`$.entity.<field>`). */
+    readonly path: EffectPath;
+    /** The comparison op applied to the source value. */
+    readonly op: MembershipPredicateOp;
+    /** The comparand for `eq` / `ne`; absent for the unary ops. */
+    readonly value?: unknown;
+}
+/**
+ * A **membership** maintenance effect (Epic #118 pattern 6 / sparse view, issue #133):
+ * on a {@link MaintainTrigger} a {@link predicate} is evaluated over the source
+ * payload, and the view row resolved by {@link targetFactory} + {@link keys} is PUT
+ * (its {@link project}ion) when the predicate holds OR DELETED when it does not. A
+ * source `removed` event always deletes the view row (the source no longer exists).
+ *
+ * ## Why this is a NEW effect (not a snapshot/collection)
+ *
+ * A {@link SnapshotEffect} only ever `SET`s (it cannot remove a row when a predicate
+ * flips false) and a {@link CollectionEffect} only appends/splices a list field —
+ * neither expresses "the WHOLE view row appears/disappears as a predicate flips". So
+ * sparse view is a distinct effect carrying a {@link predicate} and a put-or-delete
+ * realization.
+ *
+ * ## Scope (issue #133): the asynchronous (`stream`) path
+ *
+ * The put-vs-delete branch is decided by evaluating the predicate against the source
+ * image, which the host-side CDC drain ({@link import('../cdc/maintenance-drain.js')})
+ * does naturally (it already branches snapshot SET vs collection read-modify-write). A
+ * SYNCHRONOUS membership write would need the atomic transaction to choose Put-vs-Delete
+ * from a runtime predicate (DynamoDB cannot branch an item kind on a value), which is a
+ * larger runtime change deferred as a follow-up; the compile injection rejects a
+ * `mutation`-path membership effect so it is never silently mis-realized.
+ */
+interface MembershipEffect {
+    readonly kind: 'membership';
+    /** The lifecycle event of the source entity that drives the membership write. */
+    readonly trigger: MaintainTrigger;
+    /** Resolves the target (view) entity whose row appears / disappears. */
+    readonly targetFactory: () => new (...args: unknown[]) => unknown;
+    /** The key binding of the view row (path-rooted values). */
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    /** The projection PUT onto the view row when the predicate holds. */
+    readonly project: ProjectionMap;
+    /** The membership predicate (PUT when it holds, DELETE when it flips false). */
+    readonly predicate: MembershipPredicate;
+    /** The path the write travels — `stream` only for issue #133 (see header). */
+    readonly updateMode?: MaintainUpdateMode;
+    /** The consistency the write lands under (default `eventual`). */
+    readonly consistency?: MaintainConsistency;
+}
 /**
  * The union of maintenance effects a {@link SnapshotEffect}, {@link CollectionEffect},
- * or {@link CounterEffect} can be. The shared IR the maintenance graph (#124) and
- * compile injection (#125 snapshot/collection, #141 counter) consume.
+ * {@link CounterEffect}, or {@link MembershipEffect} can be. The shared IR the
+ * maintenance graph (#124) and compile injection (#125 snapshot/collection, #141
+ * counter, #133 membership) consume.
  */
-type MaintainEffect = SnapshotEffect | CollectionEffect | CounterEffect;
+type MaintainEffect = SnapshotEffect | CollectionEffect | CounterEffect | MembershipEffect;
 /**
  * A domain event (proposal §2 `emits`): an outbox `Put` drained to Streams /
  * `src/cdc/`. Derived by #87 — stored opaquely here.
@@ -2668,6 +2761,74 @@ declare function mutation(name: string, body: MutationBody): CommandPlan;
  */
 declare const definePlan: typeof mutation;
 
+/**
+ * Decorator-metadata → maintenance-graph `ViewDefinition` adapter (issue #152).
+ *
+ * ## What this replaces
+ *
+ * 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 {
+    readonly sourceClass: AnyModelClass;
+    readonly maintainedOn: readonly MaintainTrigger[];
+    readonly keys: Readonly<Record<string, EffectPath>>;
+    readonly project: ProjectionMap;
+    readonly collection?: {
+        readonly field: string;
+        readonly maxItems?: number;
+        readonly orderBy?: EffectPath;
+        readonly orderDir?: 'ASC' | 'DESC';
+    };
+    readonly predicate?: MembershipPredicate;
+}
+/** The view definition IR — an independent view row maintained from one or more sources. */
+interface ViewDefinition {
+    readonly name: string;
+    readonly viewClass: AnyModelClass;
+    readonly pattern: 'materializedView' | 'sparseView';
+    readonly slices: readonly ViewSourceSlice[];
+    readonly updateMode?: 'mutation' | 'stream';
+    readonly consistency?: 'transactional' | 'eventual';
+}
+/**
+ * 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()`.
+ *
+ * @param registry The models to scan. Defaults to `MetadataRegistry.getAll()`.
+ */
+declare function collectViewDefinitions(registry?: ReadonlyMap<Function, EntityMetadata>): ViewDefinition[];
+
 /**
  * Maintenance graph builder (Epic #118 issue #124 — the RFC B-案 core).
  *
@@ -2823,7 +2984,7 @@ interface MaintenanceGraph {
  * @param registry The models to scan. Defaults to `MetadataRegistry.getAll()`;
  *   an explicit map is accepted for tests / scoped builds.
  */
-declare function buildMaintenanceGraph(registry?: ReadonlyMap<Function, EntityMetadata>): MaintenanceGraph;
+declare function buildMaintenanceGraph(registry?: ReadonlyMap<Function, EntityMetadata>, views?: readonly ViewDefinition[]): MaintenanceGraph;
 
 /**
  * Serializable static operation specs and manifest (issue #42, Python-bridge
@@ -3240,6 +3401,8 @@ interface MaintainCollectionSpec {
     readonly maxItems?: number;
     /** The mutation-input field the items are ordered by (recorded for #130). */
     readonly orderBy?: string;
+    /** The direction `orderBy` sorts by, from the relation's `read.order` (recorded for #130). */
+    readonly orderDir?: 'ASC' | 'DESC';
 }
 /**
  * The maintenance payload an `Update` {@link TransactionItemSpec} carries when it
@@ -3576,48 +3739,6 @@ interface BridgeBundle {
     readonly operations: OperationsDocument;
 }
 
-/**
- * Single-fragment mutation → command-op compiler (issue #83, Epic #80; proposal
- * `docs/mutation-command-derivation.md` §3).
- *
- * A {@link CommandPlan} (a `mutation(...)` result) is the internal IR: a **list**
- * of write fragments to compose atomically. This module compiles the
- * **single-fragment** case end-to-end into the **same** {@link ContractMethodOp}
- * the #58 contract recorder produces, so the existing serializer
- * (`opToDefinition` → `buildCommandSpec`, `src/spec/contracts.ts` /
- * `src/spec/operations.ts`) and the existing runtimes consume it with no new
- * write substrate. The IR is already a list, so the **N-fragment atomic merge is
- * #90** — this module rejects N>1 with a clear pointer rather than half-merging.
- *
- * ## Intent → base op (proposal §3, "single fragment compile")
- *
- * | intent   | base op                                   |
- * |----------|-------------------------------------------|
- * | `create` | `PutItem` (`attribute_not_exists(PK)`)    |
- * | `update` | `UpdateItem` (key + changed fields)       |
- * | `remove` | `DeleteItem` (key)                        |
- *
- * ## `use:` resolution (the resolved fork — proposal §3, pinned spec correction)
- *
- * The fragment's **intent** selects the lifecycle; `use:` is **optional**:
- *
- * - `use:` present → adopt that {@link EntityWritesDefinition} (the **whole**
- *   `writes` set; never a single lifecycle).
- * - `use:` omitted → default to the **target model's own** `entityWrites` save
- *   contract ({@link getEntityWrites}).
- * - the resolved save contract (custom or default) has **no** entry for the
- *   intent's lifecycle, **or the target declares no `writes` at all** → the
- *   **trivial base op** for the intent (create → `Put` `attribute_not_exists(PK)`,
- *   update → `Update`, remove → `Delete`) against the plain model. So
- *   `{ create: () => PostModel, key, input }` works on a bare model.
- *
- * Either way #83 emits the **same** base op — the resolved
- * {@link LifecycleContract} only matters as the **per-fragment hook** the
- * effect-derivation issues (#84–#87) read: the resolved lifecycle's
- * {@link LifecycleContract.effects} are exposed on {@link CompiledFragment} and
- * consumed by NONE of #83 (the empty hook).
- */
-
 /**
  * A **referential-integrity assertion** derived from a `requires`
  * ({@link RequiresEffect}) effect (issue #84; proposal §2/§3). It is the
@@ -3734,11 +3855,32 @@ interface DerivedMaintainWrite {
     readonly relationProperty: string;
     /** The trigger (`<sourceLogicalName>.<event>`) that fired this maintenance. */
     readonly trigger: MaintainTrigger;
+    /**
+     * The maintenance delivery mode (Epic #118 §5.1 `updateMode`):
+     *
+     * - `'mutation'` (synchronous, the default) — the write composes into the SAME
+     *   atomic `TransactWriteItems` as the source write (#127); a snapshot `SET`,
+     *   a bounded-collection `list_append` (Phase 1 append-only), or a counter `ADD`.
+     * - `'stream'` (asynchronous, #130) — the write is NOT placed in the source tx.
+     *   Instead a **maintenance-outbox** row is emitted atomically with the source
+     *   write ({@link DerivedMaintainOutbox}) and a CDC drain
+     *   ({@link import('../cdc/maintenance-drain.js')}) applies the owner-row write
+     *   asynchronously (at-least-once, per-shard ordered). The async path realizes
+     *   the operations a single synchronous `UpdateExpression` cannot —
+     *   collection `maxItems` trim / `removed`-driven splice and a running `max`.
+     *
+     * A `stream` write is NOT composed into the synchronous maintain items; the
+     * compiler diverts it to a {@link DerivedMaintainOutbox} instead (see
+     * {@link splitMaintainByMode}). The field is carried here so a single resolved
+     * structure describes both modes (the outbox derivation reads it back).
+     */
+    readonly updateMode: 'mutation' | 'stream';
     /**
      * Whether the write mirrors a single row (`snapshot`), appends a collection item
-     * (`collection`), or applies a scalar `ADD` counter (`counter`, #141).
+     * (`collection`), applies a scalar `ADD` counter (`counter`, #141), or puts/deletes a
+     * predicate-gated view row (`membership`, #133 sparse view — stream-only).
      */
-    readonly kind: 'snapshot' | 'collection' | 'counter';
+    readonly kind: 'snapshot' | 'collection' | 'counter' | 'membership';
     /**
      * The destination row's key binding: target key field → the mutation-input param
      * that supplies it (resolved from the effect's `$.entity.<sourceField>` paths —
@@ -3766,18 +3908,44 @@ interface DerivedMaintainWrite {
         readonly field: string;
         readonly maxItems?: number;
         readonly orderBy?: string;
+        readonly orderDir?: 'ASC' | 'DESC';
     };
     /**
-     * For a `counter` write (#141 — `@aggregate(..., { pattern: 'counter', value:
-     * count() })`), the scalar `ADD`: the target {@link counter.attribute} and the
-     * signed {@link counter.delta} the trigger applies (`+1` created / `-1` removed).
-     * A counter `ADD` is commutative, so two counter writes on the SAME row MERGE (the
-     * #92 symmetric-counter collapse) rather than reject — unlike snapshot/collection.
+     * For a `counter` write, the scalar aggregate applied to the owner attribute:
+     *
+     * - `op: 'count'` (#141) — a synchronous-capable atomic `ADD #attr :delta` (the
+     *   signed `delta` is `+1` created / `-1` removed). Commutative, so two count
+     *   writes on the SAME row MERGE (the #92 symmetric-counter collapse).
+     * - `op: 'max'` (#130 — `value: max(field)`) — a running maximum of the source
+     *   `field`. This needs a conditional `SET` (`#a = :v` guarded by
+     *   `attribute_not_exists(#a) OR #a < :v`); a failed guard would roll the SOURCE
+     *   write back if done synchronously, so a `max` counter is **stream-only** —
+     *   applied by the CDC drain ({@link import('../cdc/maintenance-drain.js')}).
+     *
      * Absent for a `snapshot` / `collection`.
      */
     readonly counter?: {
         readonly attribute: string;
+        readonly op: 'count';
         readonly delta: number;
+    } | {
+        readonly attribute: string;
+        readonly op: 'max';
+        readonly field: string;
+    };
+    /**
+     * For a `membership` write (#133 sparse view), the predicate that gates the view row:
+     * PUT (its projection) when it holds, DELETE when it flips false. `inputField` is the
+     * mutation-input param the predicate reads the source value from (payload 同梱);
+     * `op` / `value` are the {@link import('../define/entity-writes.js').MembershipPredicate}
+     * realization. Membership is **stream-only** (the put-vs-delete branch is decided by
+     * the host-side drain), so this is only ever carried on a `stream` write. Absent for
+     * a `snapshot` / `collection` / `counter`.
+     */
+    readonly membership?: {
+        readonly op: MembershipPredicateOp;
+        readonly inputField: string;
+        readonly value?: unknown;
     };
 }
 /**
@@ -3891,6 +4059,43 @@ interface DerivedIdempotencyGuard {
     /** The guard marker-row `Put` (one item; `attribute_not_exists`, `literalKey`). */
     readonly items: readonly TransactionItemSpec[];
 }
+/**
+ * A **derived maintenance-outbox event** (issue #130) — the transactional-outbox
+ * `Put` ({@link TransactionItemSpec}) that records a `updateMode: 'stream'`
+ * maintainer's intent ATOMICALLY with the source write, so the `src/cdc/` drain can
+ * apply the owner-row write asynchronously (at-least-once, per-shard ordered).
+ *
+ * ## What the row carries (dynamic values only; the drain re-derives the projection)
+ *
+ * The row's `PK`/`SK` are the deterministic `OUTBOX#MAINT#…` marker (keyed by owner
+ * entity + relation property + the SOURCE row's primary-key input fields). Its
+ * stored item carries:
+ *
+ * - the routing metadata literals — {@link MAINT_OUTBOX_OWNER_ATTR} (owner entity
+ *   name), {@link MAINT_OUTBOX_RELATION_ATTR} (the relation property), and
+ *   {@link MAINT_OUTBOX_TRIGGER_ATTR} (the `<source>.<event>` trigger) — so the drain
+ *   can look the resolved maintainer up in its own maintenance graph;
+ * - one `{inputField}` token per source value the drain needs (every projection
+ *   `inputField`, the `orderBy` field, the `max` field, and every owner-key field),
+ *   rendered from the shared method params exactly as the #87 outbox payload — so the
+ *   row's `newImage` carries the just-written SOURCE row values the drain reprojects.
+ *
+ * The projection transform IR (`identity` / `preview`) is NOT stored in the row (it
+ * would need braces the template renderer reserves for `{token}`s); the drain
+ * recovers it from its maintenance graph by `(owner, relationProperty, trigger)`.
+ * Because the row is a normal table item, real DynamoDB Streams captures it and a
+ * production consumer drains it identically — the emulator is dev/test only.
+ */
+interface DerivedMaintainOutbox {
+    /** The maintained (owner) entity whose row the drain will write (documentary). */
+    readonly ownerEntity: string;
+    /** The relation property / `@aggregate` field that declared this maintenance. */
+    readonly relationProperty: string;
+    /** The trigger (`<sourceLogicalName>.<event>`) that fired this maintenance. */
+    readonly trigger: MaintainTrigger;
+    /** The maintenance-outbox marker-row `Put` (one item; `literalKey`, `MARKER_ROW_ENTITY`). */
+    readonly items: readonly TransactionItemSpec[];
+}
 /**
  * The result of compiling one fragment: the {@link ContractMethodOp} the existing
  * serializer / runtime consume, the resolved contract Key fields (the model's
@@ -3984,8 +4189,26 @@ interface CompiledFragment {
      * realizes into the atomic `TransactWriteItems`; #125 derives it and rejects a
      * same-target collision (論点2 = b). The cross-fragment AGGREGATION and the
      * one-atomic-tx execution wiring are #127 — not done here.
+     *
+     * SCOPE (#130): this carries ONLY the synchronous (`updateMode: 'mutation'`)
+     * maintainers. A `updateMode: 'stream'` maintainer is diverted to
+     * {@link maintainOutbox} instead (it is applied asynchronously by the CDC drain),
+     * so it never appears here.
      */
     readonly maintainWrites?: readonly DerivedMaintainWrite[];
+    /**
+     * The maintenance-outbox events for this fragment's `updateMode: 'stream'`
+     * maintainers (issue #130): one {@link DerivedMaintainOutbox} per stream maintainer
+     * the fragment's trigger fires. Each is a transactional-outbox `Put` composed into
+     * the source write's atomic `TransactWriteItems` — recording the maintenance intent
+     * ATOMICALLY with the source row — which the `src/cdc/` drain
+     * ({@link import('../cdc/maintenance-drain.js')}) selects (`PK begins_with
+     * 'OUTBOX#MAINT#'`) and applies asynchronously (at-least-once, per-shard ordered).
+     * Present (non-empty) only when the fragment fires at least one stream maintainer;
+     * absent otherwise (no regression — a fragment with no stream maintainer compiles
+     * exactly as before).
+     */
+    readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
 }
 /**
  * Resolve the {@link LifecycleContract} a fragment adopts for its intent:
@@ -4716,10 +4939,22 @@ interface CommandMethodSpec<TKey, TParams, TResult> {
      * otherwise single-op method to a transaction: the runtime (#127) realizes each
      * into the method's atomic `TransactWriteItems`, so the maintained row moves
      * atomically with the source write (a failure rolls the WHOLE set back). #127 is
-     * the synchronous (`updateMode: 'mutation'`) path only; the async stream path is
-     * #130 (loud-rejected at compile time, never silently dropped).
+     * the synchronous (`updateMode: 'mutation'`) path only; a `updateMode: 'stream'`
+     * maintainer is carried in {@link maintainOutbox} instead (it is applied
+     * asynchronously by the CDC drain), never in this synchronous slot.
      */
     readonly maintainWrites?: readonly DerivedMaintainWrite[];
+    /**
+     * The maintenance-outbox events for `updateMode: 'stream'` maintainers (issue
+     * #130): one {@link DerivedMaintainOutbox} per stream maintainer fired across the
+     * method's fragments. Each is a transactional-outbox `Put` the runtime composes
+     * into the method's atomic `TransactWriteItems` — recording the maintenance intent
+     * ATOMICALLY with the source write — which the `src/cdc/` drain
+     * ({@link import('../cdc/maintenance-drain.js')}) applies asynchronously
+     * (at-least-once, per-shard ordered). Present (non-empty) only when the method fires
+     * at least one stream maintainer; absent otherwise (no regression).
+     */
+    readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
     /** @internal Phantom carrier retaining the formal `CommandMethod` type. */
     readonly __signature?: CommandMethod<TKey, TParams, TResult>;
 }
@@ -5336,6 +5571,18 @@ interface ExecutableCommandContract {
          * maintainer / a #64 hand-written method.
          */
         readonly maintainWrites?: readonly DerivedMaintainWrite[];
+        /**
+         * The maintenance-outbox events for `updateMode: 'stream'` maintainers (issue
+         * #130). Each is a transactional-outbox `Put` (the same `literalKey` marker
+         * mechanism as #87's outbox) composed into the method's atomic
+         * `TransactWriteItems` — recording the maintenance intent ATOMICALLY with the
+         * source write. The `src/cdc/` drain selects these (`PK begins_with
+         * 'OUTBOX#MAINT#'`) and applies the owner-row write asynchronously (so a
+         * snapshot SET / collection append+trim / counter ADD / running-max conditional
+         * SET happens off the write path, at-least-once, per-shard ordered). Absent on a
+         * mutation with no stream maintainer.
+         */
+        readonly maintainOutbox?: readonly DerivedMaintainOutbox[];
         /**
          * The return projection of a `mutation`-derived method (issue #83). When
          * present, a **single-key** call performs the write then issues a
@@ -5831,6 +6078,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;
@@ -5860,8 +6150,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' | 'counter' | 'embeddedSnapshot' | 'materializedView' | 'sparseView' | '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.
@@ -5938,6 +6238,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';
@@ -6035,6 +6352,21 @@ 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;
+    /**
+     * 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[];
 }
 
 /**
@@ -6150,4 +6482,4 @@ interface CdcEmulatorOptions {
 }
 type ShardId = string;
 
-export { type Param 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 RelationMetadata as Z, type TransactionItemSpec as _, type ExecutorResult as a, type ContractKeySpec as a$, type ParamDescriptor as a0, type DefinitionMap as a1, type OperationDefinition as a2, type WriteDefinitionOptions as a3, type PartialQueryKeyOf as a4, type StrictSelectSpec as a5, type EntityInput as a6, type UniqueQueryKeyOf as a7, type EntityRef as a8, type ConditionInput as a9, type CollectionEffect as aA, type CollectionOptions as aB, type Column as aC, type ColumnMap as aD, type CommandContractMethodSpec as aE, type CommandInputShape as aF, type CommandMethod as aG, type CommandPlan as aH, type CommandResolutionTarget as aI, type CommandResultKind as aJ, type CommandSelectShape as aK, type CompiledFragment as aL, type ComposeSpec as aM, type CondSlot as aN, type ConditionCheckInput as aO, type Connection as aP, type ContractCallSignature as aQ, type ContractCardinality as aR, type ContractCommandParams as aS, type ContractCommandResult as aT, type ContractComposeNode as aU, type ContractFromRef as aV, type ContractInputArity as aW, type ContractItem as aX, type ContractKeyFieldRef as aY, type ContractKeyInput as aZ, type ContractKeyRef as a_, type QueryModelContract as aa, type QueryMethodSpec as ab, type CommandModelContract as ac, type CommandMethodSpec as ad, type ContractSpec as ae, type QuerySpec as af, type CommandSpec as ag, type ContextSpec as ah, type OperationsDocument as ai, type AnyOperationDefinition as aj, type BridgeBundle as ak, type ConditionSpec as al, type AggregateMetadata as am, type BatchDeleteRequest as an, type BatchGetOptions as ao, type BatchGetRequest as ap, BatchGetResult as aq, type BatchPutRequest as ar, type BatchResult as as, type BatchWriteRequest as at, CONTRACT_RANGE_FANOUT_CONCURRENCY as au, type CdcMode as av, type Change as aw, type ChangeBatch as ax, type ChangeEventName as ay, type ClockMode as az, type WriteResult as b, type MutationInputProxy as b$, type ContractKind as b0, type ContractMethodOp as b1, type ContractParamRef as b2, type ContractQueryParams as b3, type ContractResolution as b4, type CounterAggregate as b5, type CounterEffect as b6, type CtxBase as b7, DEFAULT_MAX_ATTEMPTS as b8, DEFAULT_RETRY_POLICY as b9, type KeyedResult as bA, LIFECYCLE_CONTRACT_MARKER as bB, type LifecycleContract as bC, type LifecycleEffects as bD, type LiteralParam as bE, type MaintainConsistency as bF, type MaintainEffect as bG, type MaintainEvent as bH, type MaintainItem as bI, type MaintainTrigger as bJ, type MaintainUpdateMode as bK, type MaintenanceGraph as bL, type ManifestEntity as bM, type ManifestField as bN, type ManifestFieldType as bO, type ManifestGsi as bP, type ManifestKey as bQ, type ManifestRelation as bR, type ManifestTable as bS, type ModelRef as bT, type MutateMode as bU, type MutateOptions as bV, type MutateParallelResult as bW, type MutateTransactionResult as bX, type MutationBody as bY, type MutationDescriptorMap as bZ, type MutationFragment as b_, type DeleteOptions as ba, type DeriveEffect as bb, type DerivedEdgeWrite as bc, type DerivedUpdate as bd, type DescriptorBinding as be, ENTITY_WRITES_MARKER as bf, type EdgeEffect as bg, type EffectPath as bh, type EmbeddedMetadata as bi, type EmitEffect as bj, type EntityWritesDefinition as bk, type EntityWritesShape as bl, type ExecutableCommandContract as bm, type ExecutableQueryContract as bn, type FilterInput as bo, type FilterSpec as bp, type FragmentInput as bq, type GsiDefinitionMarker as br, type GsiOptions as bs, type IdempotencyEffect as bt, type InProcessWriteDescriptor as bu, type InputArity as bv, type KeyDefinitionMarker as bw, type KeySegment as bx, type KeySlot as by, type KeyStructure as bz, type DeleteInput as c, type WriteKind as c$, type MutationInputRef as c0, type MutationIntent as c1, type NumberParam as c2, type OperationKind as c3, type OperationSpec as c4, type ParallelOpResult as c5, type ParamKind as c6, type ParamSpec as c7, type ParamStructure as c8, type PersistCtx as c9, type RelationSelect as cA, type RelationSpec as cB, type RelationUpdateMode as cC, type RelationWriteOptions as cD, type RequiresEffect as cE, type Resolution as cF, type RetryInfo as cG, type RetryOperationKind as cH, SPEC_VERSION as cI, type SegmentSpec as cJ, type SegmentedKey as cK, type SelectBuilder as cL, type SelectOf as cM, type SnapshotEffect as cN, type StartingPosition as cO, type StreamViewType as cP, type StringParam as cQ, TransactionContext as cR, type TransactionItemType as cS, type UniqueEffect as cT, type Updatable as cU, type UpdateOptions as cV, type WhenSpec as cW, type WriteCtx as cX, type WriteDescriptor as cY, type WriteEnvelope as cZ, type WriteInput as c_, type PersistOrigin as ca, type PlannedCommandMethod as cb, type ProjectionMap as cc, type ProjectionTransform as cd, type ProjectionTransformOp as ce, type PutOptions as cf, type QueryContractMethodSpec as cg, type QueryEnvelopeResult as ch, type QueryKeyOf as ci, type QueryMethod as cj, type QueryResult as ck, type RangeConditionSpec as cl, type ReadEnvelope as cm, type ReadOpCtx as cn, type ReadOpKind as co, type ReadOperationType as cp, type ReadRouteDescriptor as cq, type ReadRouteOptions as cr, type ReadRouteResult as cs, type RecordedCompose as ct, type RelationBuilder as cu, type RelationConsistency as cv, type RelationLimitOptions as cw, type RelationPattern as cx, type RelationProjection as cy, type RelationReadOptions as cz, type BatchWriteExecItem as d, resolveLifecycle as d$, type WriteLifecyclePhase as d0, type WriteMiddleware as d1, type WriteOperationType as d2, type WriteRecorder as d3, type WriteResultProjection as d4, attachModelClass as d5, buildDeleteInput as d6, buildMaintenanceGraph as d7, buildPutInput as d8, buildUpdateInput as d9, isContractFromRef as dA, isContractKeyFieldRef as dB, isContractKeyRef as dC, isContractParamRef as dD, isEntityWritesDefinition as dE, isKeySegment as dF, isLifecycleContract as dG, isMaintainTrigger as dH, isMutationFragment as dI, isMutationInputRef as dJ, isParam as dK, isPlannedCommandMethod as dL, isQueryModelContract as dM, isRetryableError as dN, isRetryableTransactionCancellation as dO, k as dP, key as dQ, lifecyclePhaseForIntent as dR, maintainTrigger as dS, mintContractKeyFieldRef as dT, mintContractParamRef as dU, mutation as dV, param as dW, preview as dX, publicCommandModel as dY, publicQueryModel as dZ, query as d_, compileFragment as da, compileMutationPlan as db, compileSingleFragmentPlan as dc, cond as dd, contractOfMethodSpec as de, definePlan as df, entityWrites as dg, executeBatchGet as dh, executeBatchWrite as di, executeCommandMethod as dj, executeDelete as dk, executeKeyedBatchGet as dl, executePut as dm, executeQueryMethod as dn, executeRangeFanout as dp, executeTransaction as dq, executeUpdate as dr, from as ds, getEntityWrites as dt, gsi as du, identity as dv, isColumn as dw, isCommandModelContract as dx, isCommandPlan as dy, isContractComposeNode as dz, type BatchExecOptions as e, wholeKeysSentinel as e0, 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 ContractCommandParams 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, type BatchPutRequest as aA, type BatchResult as aB, type BatchWriteRequest as aC, CONTRACT_RANGE_FANOUT_CONCURRENCY as aD, type CdcMode as aE, type Change as aF, type ChangeBatch as aG, type ChangeEventName as aH, type ClockMode as aI, type CollectionEffect as aJ, type CollectionOptions as aK, type Column as aL, type ColumnMap as aM, type CommandContractMethodSpec as aN, type CommandInputShape as aO, type CommandMethod as aP, type CommandPlan as aQ, type CommandResolutionTarget as aR, type CommandResultKind as aS, type CommandSelectShape as aT, type CompiledFragment as aU, type ComposeSpec as aV, type CondSlot as aW, type ConditionCheckInput as aX, type Connection as aY, type ContractCallSignature as aZ, type ContractCardinality as a_, type DefinitionMap as aa, type OperationDefinition as ab, type WriteDefinitionOptions as ac, type PartialQueryKeyOf as ad, type StrictSelectSpec as ae, type EntityInput as af, type UniqueQueryKeyOf as ag, type EntityRef as ah, type ConditionInput as ai, type QueryModelContract as aj, type QueryMethodSpec as ak, type CommandModelContract as al, type CommandMethodSpec as am, type ContractSpec as an, type QuerySpec as ao, type CommandSpec as ap, type ContextSpec as aq, type OperationsDocument as ar, type AnyOperationDefinition as as, type BridgeBundle as at, type ConditionSpec as au, type AggregateMetadata as av, type BatchDeleteRequest as aw, type BatchGetOptions as ax, type BatchGetRequest as ay, BatchGetResult as az, type WriteResult as b, type MutateOptions as b$, type ContractCommandResult as b0, type ContractComposeNode as b1, type ContractFromRef as b2, type ContractInputArity as b3, type ContractItem as b4, type ContractKeyFieldRef as b5, type ContractKeyInput as b6, type ContractKeyRef as b7, type ContractKeySpec as b8, type ContractKind as b9, type GsiDefinitionMarker as bA, type GsiOptions as bB, type IdempotencyEffect as bC, type InProcessWriteDescriptor as bD, type InputArity as bE, type KeyDefinitionMarker as bF, type KeySegment as bG, type KeySlot as bH, type KeyStructure as bI, type KeyedResult as bJ, LIFECYCLE_CONTRACT_MARKER as bK, type LifecycleContract as bL, type LifecycleEffects as bM, type LiteralParam as bN, type MaintainItem as bO, type MaintainTrigger as bP, type MaintenanceGraph as bQ, type ManifestEntity as bR, type ManifestField as bS, type ManifestFieldType as bT, type ManifestGsi as bU, type ManifestKey as bV, type ManifestRelation as bW, type ManifestTable as bX, type MembershipEffect as bY, type ModelRef as bZ, type MutateMode as b_, type ContractMethodOp as ba, type ContractParamRef as bb, type ContractQueryParams as bc, type ContractResolution as bd, type CounterAggregate as be, type CounterEffect as bf, type CtxBase as bg, DEFAULT_MAX_ATTEMPTS as bh, DEFAULT_RETRY_POLICY as bi, type DeleteOptions as bj, type DeriveEffect as bk, type DerivedEdgeWrite as bl, type DerivedUpdate as bm, type DescriptorBinding as bn, ENTITY_WRITES_MARKER as bo, type EdgeEffect as bp, type EffectPath as bq, type EmbeddedMetadata as br, type EmitEffect as bs, type EntityWritesDefinition as bt, type EntityWritesShape as bu, type ExecutableCommandContract as bv, type ExecutableQueryContract as bw, type FilterInput as bx, type FilterSpec as by, type FragmentInput as bz, type DeleteInput as c, type ViewSourceSlice as c$, type MutateParallelResult as c0, type MutateTransactionResult as c1, type MutationBody as c2, type MutationDescriptorMap as c3, type MutationFragment as c4, type MutationInputProxy as c5, type MutationInputRef as c6, type MutationIntent as c7, type NumberParam as c8, type OperationKind as c9, type RelationConsistency as cA, type RelationLimitOptions as cB, type RelationPattern as cC, type RelationProjection as cD, type RelationReadOptions as cE, type RelationSelect as cF, type RelationSpec as cG, type RelationUpdateMode as cH, type RelationWriteOptions as cI, type RequiresEffect as cJ, type Resolution as cK, type RetryInfo as cL, type RetryOperationKind as cM, SPEC_VERSION as cN, type SegmentSpec as cO, type SegmentedKey as cP, type SelectBuilder as cQ, type SelectOf as cR, type SnapshotEffect as cS, type StartingPosition as cT, type StreamViewType as cU, type StringParam as cV, TransactionContext as cW, type TransactionItemType as cX, type UniqueEffect as cY, type Updatable as cZ, type UpdateOptions as c_, type OperationSpec as ca, type ParallelOpResult as cb, type ParamKind as cc, type ParamSpec as cd, type ParamStructure as ce, type PersistCtx as cf, type PersistOrigin as cg, type PlannedCommandMethod as ch, type ProjectionMap as ci, type ProjectionTransformOp as cj, type PutOptions as ck, type QueryContractMethodSpec as cl, type QueryEnvelopeResult as cm, type QueryKeyOf as cn, type QueryMethod as co, type QueryResult as cp, type RangeConditionSpec as cq, type ReadEnvelope as cr, type ReadOpCtx as cs, type ReadOpKind as ct, type ReadOperationType as cu, type ReadRouteDescriptor as cv, type ReadRouteOptions as cw, type ReadRouteResult as cx, type RecordedCompose as cy, type RelationBuilder as cz, type BatchWriteExecItem as d, mintContractParamRef as d$, type WhenSpec as d0, type WriteCtx as d1, type WriteDescriptor as d2, type WriteEnvelope as d3, type WriteInput as d4, type WriteKind as d5, type WriteLifecyclePhase as d6, type WriteMiddleware as d7, type WriteOperationType as d8, type WriteRecorder as d9, getEntityWrites as dA, gsi as dB, identity as dC, isColumn as dD, isCommandModelContract as dE, isCommandPlan as dF, isContractComposeNode as dG, isContractFromRef as dH, isContractKeyFieldRef as dI, isContractKeyRef as dJ, isContractParamRef as dK, isEntityWritesDefinition as dL, isKeySegment as dM, isLifecycleContract as dN, isMaintainTrigger as dO, isMutationFragment as dP, isMutationInputRef as dQ, isParam as dR, isPlannedCommandMethod as dS, isQueryModelContract as dT, isRetryableError as dU, isRetryableTransactionCancellation as dV, k as dW, key as dX, lifecyclePhaseForIntent as dY, maintainTrigger as dZ, mintContractKeyFieldRef as d_, type WriteResultProjection as da, attachModelClass as db, buildDeleteInput as dc, buildMaintenanceGraph as dd, buildPutInput as de, buildUpdateInput as df, collectViewDefinitions as dg, compileFragment as dh, compileMutationPlan as di, compileSingleFragmentPlan as dj, cond as dk, contractOfMethodSpec as dl, definePlan as dm, entityWrites as dn, executeBatchGet as dp, executeBatchWrite as dq, executeCommandMethod as dr, executeDelete as ds, executeKeyedBatchGet as dt, executePut as du, executeQueryMethod as dv, executeRangeFanout as dw, executeTransaction as dx, executeUpdate as dy, from as dz, type BatchExecOptions as e, mutation as e0, param as e1, preview as e2, publicCommandModel as e3, publicQueryModel as e4, query as e5, resolveLifecycle as e6, wholeKeysSentinel as e7, 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 };