graphddb 0.7.9 → 0.8.0

package/dist/index.d.ts

@@ -1,12 +1,8 @@
-export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-CXhP4TaE.js';
-import { aO as SelectableOf, aP as PrimaryKeyOf, aQ as RequestContext, aR as Middleware, aS as ReadRequestKind, aT as CtxModel, aU as ReadParams, aV as ReadRequestCtx, D as DynamoDBOperation, aW as Item, n as Executor, aX as RetryPolicy, ap as ExecutionPlanSpec, aY as RetryOverride, aZ as KeyDefinition, a_ as GsiDefinition, a$ as ModelKind, b0 as FieldOptions, b1 as DynamoType, b2 as ProjectionTransform, b3 as MaintainEvent, b4 as MembershipPredicate, b5 as MaintainConsistency, b6 as MaintainUpdateMode, b7 as MembershipPredicateOp, b8 as RelationOptions, b9 as AggregateOptions, ba as AggregateValue, bb as SelectBuilderSpec, bc as RawCondition, m as EntityMetadata, I as TransactionSpec, a0 as Manifest, bd as ExecutionPlan, be as FieldMetadata, bf as ResolvedKey, o as ReadExecOptions, p as ExecutorResult, q as BatchGetExecInput, P as PutInput, W as WriteExecOptions, r as WriteResult, s as UpdateInput, t as DeleteInput, u as BatchWriteExecItem, v as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, w as DDBModel, bg as Slot, bh as PreparedWriteExecOptions, bi as CommandReturn, bj as ParallelOpResult, a3 as PreparedBody, bk as PreparedStatement, bl as RelationMetadata, aD as TransactionItemSpec, bm as MaintainEffect, V as ViewDefinition, Y as Param, N as ParamDescriptor, Z as DefinitionMap, bn as OperationDefinition, bo as WriteDefinitionOptions, bp as PartialQueryKeyOf, bq as StrictSelectSpec, br as ReadDefinitionOptions, bs as EntityInput, bt as UniqueQueryKeyOf } from './maintenance-view-adapter-BATUh_I8.js';
-export { bu as AggregateMetadata, $ as AnyOperationDefinition, bv as BatchDeleteRequest, bw as BatchGetOptions, bx as BatchGetRequest, by as BatchGetResult, bz as BatchPutRequest, B as BatchResult, bA as BatchWriteRequest, a1 as BridgeBundle, bB as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bC as CdcModelRegistry, bD as CdcSubscribeHandlers, bE as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bF as CollectionEffect, bG as CollectionOptions, bH as Column, bI as ColumnMap, a4 as CommandContractMethodSpec, bJ as CommandInputShape, bK as CommandMethod, z as CommandMethodSpec, y as CommandModelContract, bL as CommandPlan, a5 as CommandResolutionTarget, bM as CommandResultKind, bN as CommandSelectShape, H as CommandSpec, a6 as CompiledFragment, a8 as ComposeSpec, g as ConcurrentRecomputeRef, bO as CondSlot, bP as ConditionCheckInput, X as ConditionInput, a2 as ConditionSpec, bQ as Connection, J as ContextSpec, bR as ContractCallSignature, aa as ContractCardinality, bS as ContractCommandParams, ab as ContractCommandResult, bT as ContractComposeNode, bU as ContractFromRef, ac as ContractInputArity, bV as ContractItem, bW as ContractKeyFieldRef, bX as ContractKeyInput, bY as ContractKeyRef, ad as ContractKeySpec, ae as ContractKind, bZ as ContractMethodOp, b_ as ContractParamRef, b$ as ContractQueryParams, af as ContractResolution, A as ContractSpec, c0 as CounterAggregate, c1 as CounterEffect, c2 as CtxBase, c3 as DEFAULT_MAX_ATTEMPTS, c4 as DEFAULT_RETRY_POLICY, c5 as DeleteOptions, c6 as DeriveEffect, ah as DerivedEdgeWrite, an as DerivedUpdate, c7 as DescriptorBinding, c8 as ENTITY_WRITES_MARKER, c9 as EdgeEffect, ca as EffectPath, cb as EmbeddedMetadata, cc as EmitEffect, O as EntityRef, cd as EntityWritesDefinition, ce as EntityWritesShape, E as EventLog, cf as ExecutableCommandContract, cg as ExecutableQueryContract, F as FaultSpec, ch as FilterInput, aq as FilterSpec, ci as FragmentCondition, cj as FragmentConditionOperatorObject, ck as FragmentInput, cl as GsiDefinitionMarker, cm as GsiOptions, cn as IdempotencyEffect, co as InProcessWriteDescriptor, cp as InlineSnapshotSpec, cq as InputArity, cr as KeyDefinitionMarker, cs as KeySegment, ct as KeySlot, cu as KeyStructure, cv as KeyedResult, cw as LIFECYCLE_CONTRACT_MARKER, cx as LifecycleContract, cy as LifecycleEffects, cz as LiteralParam, cA as MaintainItem, cB as MaintainTrigger, cC as MaintenanceGraph, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, cD as MembershipEffect, cE as ModelRef, cF as MutateMode, cG as MutateOptions, cH as MutateParallelResult, cI as MutateTransactionResult, cJ as MutationBody, cK as MutationDescriptorMap, cL as MutationFragment, cM as MutationInputProxy, cN as MutationInputRef, cO as MutationIntent, cP as NumberParam, cQ as OperationKind, az as OperationSpec, _ as OperationsDocument, cR as PREPARE_CACHE_MAX, cS as ParamKind, L as ParamSpec, cT as ParamStructure, cU as PersistCtx, cV as PersistOrigin, cW as PlannedCommandMethod, cX as PreparedInputProxy, cY as PreparedParamRef, cZ as PreparedReadExecOptions, c_ as PreparedReadRoute, c$ as PreparedReadStatement, d0 as PreparedWriteRoute, d1 as PreparedWriteStatement, d2 as ProjectionMap, d3 as ProjectionTransformOp, d4 as PutOptions, aA as QueryContractMethodSpec, d5 as QueryEnvelopeResult, d6 as QueryKeyOf, d7 as QueryMethod, x as QueryMethodSpec, Q as QueryModelContract, d8 as QueryResult, G as QuerySpec, aB as RangeConditionSpec, d9 as ReadEnvelope, da as ReadOpCtx, db as ReadOpKind, aC as ReadOperationType, dc as ReadRouteDescriptor, dd as ReadRouteOptions, de as ReadRouteResult, df as RecordedCompose, dg as RelationBuilder, dh as RelationConsistency, di as RelationLimitOptions, dj as RelationPattern, dk as RelationProjection, dl as RelationReadOptions, dm as RelationSelect, dn as RelationSpec, dp as RelationUpdateMode, dq as RelationWriteOptions, R as ReplayOptions, dr as RequiresEffect, ds as Resolution, dt as RetryInfo, du as RetryOperationKind, K as SPEC_VERSION, dv as SegmentSpec, dw as SegmentedKey, dx as SelectBuilder, dy as SelectOf, S as ShardId, dz as SnapshotEffect, h as StartingPosition, i as StreamViewType, dA as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dB as TransactionContext, aE as TransactionItemType, dC as UniqueEffect, dD as Updatable, dE as UpdateOptions, dF as ViewSourceSlice, aF as WhenSpec, dG as WriteCtx, dH as WriteDescriptor, dI as WriteEnvelope, dJ as WriteInput, dK as WriteKind, dL as WriteLifecyclePhase, dM as WriteMiddleware, aG as WriteOperationType, dN as WriteRecorder, dO as WriteResultProjection, dP as attachModelClass, dQ as buildDeleteInput, dR as buildMaintenanceGraph, dS as buildPutInput, l as buildSubscribeHandler, dT as buildUpdateInput, dU as collectViewDefinitions, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, dV as cond, dW as contractOfMethodSpec, dX as definePlan, dY as entityWrites, dZ as executeBatchGet, d_ as executeBatchWrite, d$ as executeCommandMethod, e0 as executeDelete, e1 as executeKeyedBatchGet, e2 as executePut, e3 as executeQueryMethod, e4 as executeRangeFanout, e5 as executeTransaction, e6 as executeUpdate, e7 as from, e8 as getEntityWrites, e9 as gsi, ea as identity, eb as isColumn, ec as isCommandModelContract, ed as isCommandPlan, ee as isContractComposeNode, ef as isContractFromRef, eg as isContractKeyFieldRef, eh as isContractKeyRef, ei as isContractParamRef, ej as isEntityWritesDefinition, ek as isKeySegment, el as isLifecycleContract, em as isMaintainTrigger, en as isMutationFragment, eo as isMutationInputRef, ep as isParam, eq as isPlannedCommandMethod, er as isPreparedParamRef, es as isQueryModelContract, et as isRetryableError, eu as isRetryableTransactionCancellation, ev as k, ew as key, ex as lifecyclePhaseForIntent, ey as maintainTrigger, ez as mintContractKeyFieldRef, eA as mintContractParamRef, eB as mutation, eC as param, eD as prepare, eE as preview, eF as publicCommandModel, eG as publicQueryModel, eH as query, aM as resolveLifecycle, eI as wholeKeysSentinel } from './maintenance-view-adapter-BATUh_I8.js';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from './from-change-DanwjE5b.js';
-import { P as PreparedWriteOpSpec, a as PreparedPlanDocument } from './index-CtPJSMrc.js';
-export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, b as ContextOwnershipMap, c as ContractBoundaryViolation, d as ContractInputs, e as ContractMap, f as ContractN1Violation, g as PreparedBindSpec, h as PreparedPlanSpec, i as PreparedReadRouteSpec, T as TransactionDefinition, j as TransactionParamShape, k as TransactionRef, l as TxConditionCheckOptions, m as TxForEachInstruction, n as TxForEachOptions, o as TxInstruction, p as TxRecorder, q as TxWriteInstruction, r as TxWriteOptions, W as WhenComparison, s as assertBundleSerializable, t as assertContractBoundaries, u as assertContractN1Safe, v as assertJsonSerializable, w as assertSupportedCondition, x as buildBridgeBundle, y as buildContexts, z as buildContracts, D as buildManifest, E as buildOperations, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, I as collectContractBoundaryViolations, J as collectContractN1Violations, K as defineTransaction, L as defineTransactions, M as isTransactionRef, N as when } from './index-CtPJSMrc.js';
-export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from './relation-depth-Dg3yhl7S.js';
+import { ak as SelectableOf, al as PrimaryKeyOf, e as ProjectionTransform, f as MaintainEvent, j as MembershipPredicate, h as MaintainConsistency, i as MaintainUpdateMode, am as MembershipPredicateOp, an as publishQuery, ao as publishCommand, D as DDBModel, ap as RetryPolicy, aq as Middleware } from './key-DR7_lpyk.js';
+export { ar as CdcModelRegistry, as as CdcSubscribeHandlers, at as Change, au as Column, av as ColumnMap, aw as CondSlot, ax as CtxBase, ay as CtxModel, az as FilterInput, aA as GsiDefinitionMarker, aB as GsiOptions, aC as InlineSnapshotSpec, aD as Item, aE as KeyDefinitionMarker, aF as KeySegment, aG as KeySlot, aH as KeyStructure, M as ModelStatic, aI as MutateAuthoringOptions, aJ as ParamDescriptor, aK as ParamStructure, aL as PartialQueryKeyOf, aM as PersistCtx, aN as PersistOrigin, aO as QueryKeyOf, aP as QueryResult, aQ as RawCondition, aR as ReadOpCtx, aS as ReadOpKind, aT as ReadParams, aU as ReadRequestCtx, aV as ReadRequestKind, aW as RelationBuilder, aX as RelationSelect, aY as RelationSpec, aZ as RequestContext, a_ as SegmentSpec, d as SegmentedKey, a$ as SelectBuilder, b0 as SelectOf, b1 as UniqueQueryKeyOf, b2 as Updatable, b3 as WriteCtx, b4 as WriteInput, b5 as WriteKind, b6 as WriteMiddleware, b7 as cond, b8 as entityWrites, b9 as getEntityWrites, ba as gsi, bb as identity, bc as k, bd as key, be as mutate, bf as preview, bg as when } from './key-DR7_lpyk.js';
+import * as _aws_sdk_client_dynamodb from '@aws-sdk/client-dynamodb';
+import { M as ModelKind, F as FieldOptions, D as DynamoType, R as RelationOptions, A as AggregateOptions, a as AggregateValue } from './types-BXLzIcQD.js';
+export { $ as LiteralParam, a0 as NumberParam, a1 as Param, a2 as ParamKind, a3 as StringParam, a4 as param } from './types-2PMXEn5x.js';
 
 /**
  * Query options with conditional `consistentRead` availability.
@@ -17,7 +13,7 @@ export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n
  * @typeParam Key - The query key type used in this call
  * @typeParam ModelClass - The model class constructor (`typeof UserModel`)
  */
-type QueryOptions$1<Key, ModelClass> = [Key] extends [
+type QueryOptions<Key, ModelClass> = [Key] extends [
     PrimaryKeyOf<ModelClass>
 ] ? {
     consistentRead?: boolean;
@@ -37,403 +33,6 @@ type ListOptions<T, S extends SelectableOf<T> = SelectableOf<T>> = {
     order?: 'ASC' | 'DESC';
 };
 
-/**
- * Read-middleware runtime (issue #138). Drives the registered {@link Middleware}
- * list through the read hook points R1–R5 with the ordering docs/middleware.md
- * specifies:
- *
- * - `before*` (R1 / R2) run **first-registered-first** (FIFO);
- * - `afterFetch` (R3 / R4) and `onError` (R5) run **last-registered-first**
- *   (LIFO) — onion nesting without a `next()` callback.
- *
- * All hooks are async-first: each is always `await`ed, so a sync hook (returns
- * `void` / a value) and an async hook (returns a `Promise`) compose uniformly.
- *
- * A {@link MiddlewareRuntime} is constructed ONCE per read at the request entry
- * (R1) from the snapshot of registered middleware + the per-call `context`, then
- * threaded — unchanged — through the root read and every relation fan-out op
- * (the same way `retry` is threaded, see `RelationTraversalOptions`). Threading
- * an immutable runtime (not re-reading the registry per op) keeps a read's hook
- * set stable even if middleware is (un)registered mid-flight, and is
- * concurrency-safe under parallel fan-out (#31).
- *
- * @see docs/middleware.md
- */
-
-/**
- * The per-read middleware runtime. Immutable wrt the middleware list and the
- * request `context`; threaded by reference into every fan-out op. A read with no
- * registered middleware is represented by an EMPTY runtime whose `active` is
- * `false`, so the hot read path can skip all hook plumbing with one check.
- */
-declare class MiddlewareRuntime {
-    /** The frozen, registration-ordered middleware snapshot for this read. */
-    private readonly chain;
-    /** The host-injected per-call context (`{}` when the read passed none). */
-    readonly context: RequestContext;
-    constructor(chain: readonly Middleware[], context: RequestContext);
-    /** `true` when at least one middleware is registered for this read. */
-    get active(): boolean;
-    /**
-     * Build the request-level context (R1 / R4 / R5 share it). Pure — no hooks run
-     * — so a caller can create it up front and still reference it from R5 even if
-     * R1 throws mid-chain.
-     */
-    requestCtx(kind: ReadRequestKind, model: CtxModel, params: ReadParams): ReadRequestCtx;
-    /**
-     * R1 — request entry, before key-resolution / plan. Builds the
-     * {@link ReadRequestCtx} then runs every `read.before` FIFO; a hook may mutate
-     * `ctx.params` and may `throw` to cancel the read. Returns the (possibly
-     * hook-mutated) ctx so the caller can re-read `params` and reuse the SAME ctx
-     * for R4 / R5 (shared `state`).
-     */
-    runRequestBefore(kind: ReadRequestKind, model: CtxModel, params: ReadParams): Promise<ReadRequestCtx>;
-    /**
-     * R4 — final hydrated, relation-merged result. Runs every `read.afterFetch`
-     * LIFO, threading each hook's return value into the next (onion), and returns
-     * the final (possibly replaced) result. `ctx` is the SAME object R1 produced,
-     * so a `before`/`afterFetch` pair shares `ctx.state`.
-     */
-    runRequestAfter<T>(ctx: ReadRequestCtx, result: T): Promise<T>;
-    /**
-     * R5 (request-level) — runs every `read.onError` LIFO. A hook may **recover**
-     * by RETURNING a non-`undefined` value: it becomes the read's resolved result
-     * in place of throwing, and the FIRST such hook (in LIFO order) wins and
-     * short-circuits the rest of the chain. If every hook declines (returns
-     * `undefined`/`void`), the original error rethrows — preserving the
-     * "failed read still rejects" default. (Proposal R5 + appendix A: onError may
-     * "rethrow / recover"; hooks are unrestricted.)
-     *
-     * The recovered value is returned as `T` (the read's result type); its shape
-     * is the host's responsibility — a hook recovering a `query` should return an
-     * item / `null`, one recovering a `list` a `{ items, cursor }`.
-     */
-    runRequestError<T>(ctx: ReadRequestCtx, err: unknown): Promise<T>;
-    /**
-     * Drive ONE physical op (root read or any fan-out fetch) through R2 → send →
-     * R3, with R5 (op-level) on failure:
-     *
-     * 1. R2 (`read.op.before`, FIFO) — may mutate `ctx.operation`, may `throw`;
-     * 2. the caller's `send` runs against the (possibly mutated) operation;
-     * 3. R3 (`read.op.afterFetch`, LIFO) — transforms the raw items (onion);
-     * 4. on any throw from `send` (or R2 / R3), R5 (`read.op.onError`, LIFO) runs:
-     *    a hook may **recover** by RETURNING an `Item[]` (those become this op's
-     *    items and the pipeline continues); the FIRST hook that returns items wins
-     *    and short-circuits the chain. If none recovers, the original error
-     *    rethrows.
-     *
-     * Returns the (possibly R3-replaced, or R5-recovered) items. The `send` closure
-     * receives the final operation so a caller that built its operation from
-     * `ctx.operation` before this call still observes an R2 mutation (the caller
-     * MUST send `ctx.operation`, which this method passes through).
-     */
-    runOp(operation: DynamoDBOperation, relationPath: readonly string[], model: CtxModel, send: (operation: DynamoDBOperation) => Promise<Item[]>): Promise<Item[]>;
-}
-
-/**
- * The ONE shared `TransactWriteItems` commit orchestration (issue #97).
- *
- * Every TS path that renders a transaction's resolved items into a single atomic
- * `TransactWriteItems` — the in-process command runtime's single-key derived-effect
- * composition ({@link import('./command-runtime.js')}'s `executeReferentialTransaction`)
- * and its array-of-keys / #90 multi-fragment writes path (`executeTransactWrites`), the
- * declarative spec executor ({@link import('../operations/declarative-transaction.js')}'s
- * `executeDeclarativeTransaction`), and the public imperative
- * {@link import('../operations/transaction.js').TransactionContext} (`executeTransaction`)
- * — performs the SAME four steps, in this order:
- *
- *  1. **collapse** same-physical-key collisions, op-aware ({@link collapseSameKey}, the
- *     #93 rule shared with Python `_collapse_same_key_items`);
- *  2. enforce the DynamoDB **≤25** hard limit ({@link MAX_TRANSACT_ITEMS}) — a transaction
- *     is atomic and CANNOT be split, so a >25 set is rejected, never chunked;
- *  3. **commit** atomically via {@link Executor.transactWrite};
- *  4. post-commit **capture** — feed each committed item into the in-process
- *     change-capture seam (issue #72 / #94), gated on
- *     {@link ChangeCaptureRegistry.hasSubscribers} for zero overhead.
- *
- * The root cause behind #93 and #94 was that these four steps were DUPLICATED across the
- * four callers, so a fix (the #93 `Put`+`Update` reject; the #94 capture) landed on some
- * paths and was missed on others (the path-takeoff bug recurred twice). This module is the
- * SINGLE place that orchestration lives. Each caller's job is reduced to building its own
- * items (per-caller, because item shapes and model-labeling differ) and handing them — plus
- * an optional model-label map and an optional limit-error customizer — to
- * {@link commitTransaction}. No caller carries its own collapse / ≤25 / commit / capture.
- *
- * Capture runs ONLY after a successful commit: a rolled-back (cancelled) transaction throws
- * out of {@link Executor.transactWrite} before reaching the capture step and therefore emits
- * ZERO events — the same post-commit semantics every single-op write path already has.
- * Production via real DynamoDB Streams is unaffected (Streams capture at the table layer
- * regardless of code path). Python is already single-path: every transaction write routes
- * through `GraphDDBRuntime.execute_transaction` → `TransactionExpander.expand` (collapse +
- * ≤25) → boto3 `transact_write_items`, and captures via real Streams, so it mirrors this
- * one TS path branch-for-branch.
- */
-
-/**
- * The DynamoDB `TransactWriteItems` item cap (25). A transaction is atomic, so a set larger
- * than this CANNOT be split across requests without breaking atomicity — every transaction
- * path rejects an over-limit set rather than chunking it ({@link commitTransaction}). This is
- * the SINGLE definition of the limit; the public {@link
- * import('../operations/transaction.js')} re-exports it for the imperative
- * `TransactionContext` API surface.
- */
-declare const MAX_TRANSACT_ITEMS = 25;
-
-declare class ClientManager {
-    private static client;
-    private static documentClient;
-    /**
-     * The active I/O executor (issue #76). `null` ⇒ use the lazily-constructed
-     * default {@link DynamoExecutor}. Tests / the memory adapter replace it via
-     * {@link setExecutor}. Constructed lazily (and imported lazily) so importing
-     * GraphDDB for planning / linting / codegen never pulls in the AWS SDK.
-     */
-    private static executor;
-    private static defaultExecutor;
-    /**
-     * The globally-configured single-op retry policy (issue #111). `null` ⇒ the
-     * always-on built-in {@link DEFAULT_RETRY_POLICY} applies (retry is enabled out
-     * of the box). Set via {@link DDBModel.setRetryPolicy} / {@link setRetryPolicy};
-     * read at call time by the default {@link RetryingExecutor}.
-     */
-    private static retryPolicy;
-    /**
-     * The host-runtime read-middleware registry (issue #50 / #138) — a process-wide
-     * ordered list of {@link Middleware}, the same global-config + injectable-seam
-     * pattern as {@link retryPolicy} / {@link executor}. Registered via
-     * {@link DDBModel.use} / {@link use}, snapshotted per read, and NEVER serialized
-     * (it never touches the planner / spec / `operations.json`, so the bridge #48 is
-     * unaffected). {@link reset} clears it.
-     */
-    private static middleware;
-    static setClient(client: DynamoDBClient): void;
-    static getClient(): DynamoDBClient;
-    static getDocumentClient(): Promise<DynamoDBDocumentClient>;
-    /**
-     * The active I/O executor (issue #76). All read/write I/O flows through this
-     * seam. Defaults to a {@link DynamoExecutor} (current real-DynamoDB
-     * behavior); tests inject a `MemoryExecutor` via {@link setExecutor}.
-     *
-     * The default is constructed lazily and imported lazily so importing
-     * GraphDDB for planning / linting / codegen does not eagerly load the
-     * executor module graph.
-     */
-    static getExecutor(): Executor;
-    /**
-     * Inject a custom executor (test adapter / memory engine). It is used AS-IS —
-     * not wrapped in a {@link RetryingExecutor} — so the in-memory adapter (which
-     * never throttles) bypasses the retry layer entirely (issue #111).
-     */
-    static setExecutor(executor: Executor): void;
-    /** Restore the default {@link RetryingExecutor}-wrapped {@link DynamoExecutor}. */
-    static resetExecutor(): void;
-    /**
-     * Configure the global single-op retry policy (issue #111). Mirrors
-     * {@link setClient} / {@link setTableMapping}: a process-wide setting the default
-     * {@link RetryingExecutor} reads. `null` restores the always-on built-in default.
-     * A per-call `retry?:` override on an operation option bag takes precedence.
-     */
-    static setRetryPolicy(policy: RetryPolicy | null): void;
-    /** The globally-configured retry policy, or `null` for the built-in default. */
-    static getRetryPolicy(): RetryPolicy | null;
-    /**
-     * Register a read {@link Middleware} (issue #50 / #138). Appended last, so its
-     * `before*` hooks run last (FIFO) and its `afterFetch` / `onError` hooks run
-     * first (LIFO). Mirrors {@link setRetryPolicy}; backs {@link DDBModel.use}.
-     */
-    static use(mw: Middleware): void;
-    /** Remove every registered read middleware (teardown / tests). Backs {@link DDBModel.clearMiddleware}. */
-    static clearMiddleware(): void;
-    /**
-     * A point-in-time, registration-ordered snapshot of the registered read
-     * middleware. A read takes this once at entry (R1) and threads it down, so the
-     * read's hook set stays stable even if middleware is registered / cleared
-     * mid-flight.
-     */
-    static getMiddleware(): readonly Middleware[];
-    /** @internal — for testing only */
-    static reset(): void;
-}
-
-/**
- * Maximum number of keys allowed in a single DynamoDB BatchGetItem request.
- */
-declare const BATCH_GET_MAX_KEYS = 100;
-/**
- * Maximum number of items allowed in a single DynamoDB BatchWriteItem request.
- */
-declare const BATCH_WRITE_MAX_ITEMS = 25;
-
-/**
- * The single source of truth for **relation execution staging** (issue #70),
- * shared by the static SSoT generator (`src/spec/operations.ts`,
- * {@link buildQuerySpec}) and the TS host runtime
- * (`src/relation/traversal.ts`, {@link resolveRelations}). It is the TS analogue
- * of the Python runtime's `_relation_stages` / `_plan_concurrency`
- * (`python/graphddb_runtime/runtime.py`).
- *
- * ## Why one shared module (anti-drift)
- *
- * #70a records an {@link ExecutionPlanSpec} (`groups` + `concurrency`) in the
- * SSoT; #70b made the Python runtime **honor** it; #70c makes the TS host runtime
- * honor it too. For the two runtimes to make **identical** plan-declared
- * decisions, TS must consume *the same plan facts* the generator serialized — not
- * re-derive parallelism by an independent "parallelize every sibling" walk. The
- * host runtime has no generated JSON to load (it works off live decorator
- * metadata + a `select` tree), so it derives the plan from that live tree using
- * **this exact function** — the same one the generator calls to produce the
- * serialized `executionPlan`. Generator and runtime therefore cannot drift: they
- * are one codepath. {@link deriveExecutionPlan} is the seam.
- *
- * ## How the runtime obtains the plan
- *
- * The generator produces `operations[]` (root + relation ops, each with a
- * `resultPath`) and runs {@link deriveExecutionPlan} over their result paths. The
- * host runtime walks the live `select` tree with {@link relationResultPaths},
- * which emits the **identical** ordered `resultPath` list
- * (`buildRelationOperations` is refactored to use it), and runs the **same**
- * {@link deriveExecutionPlan} over `['$', ...those]`. The resulting
- * {@link ExecutionPlanSpec} is threaded through the recursive relation traversal:
- * at each parent level the traversal honors the plan's grouping (which child ops
- * are an independent, concurrency-eligible stage) and the declared `concurrency`
- * bound — reading them from the plan, never re-deciding them.
- */
-
-/**
- * A **resolved** relation execution plan as the host runtime consumes it: the
- * serialized {@link ExecutionPlanSpec} (`groups` over operation indices +
- * `concurrency`) together with the `resultPath` each operation index produces, so
- * the recursive traversal can locate "the operations at this parent level" and
- * read their declared stage from the plan.
- *
- * Built once at a read's entry point ({@link buildRelationExecutionPlan}) and
- * threaded, unchanged, through every recursion level. A read whose `select` has
- * **no** relations (or where the plan would be a single op) carries no plan; the
- * traversal then has nothing to stage.
- */
-interface RelationExecutionPlan {
-    /** The serialized staging facts (issue #70a) the traversal honors. */
-    readonly plan: ExecutionPlanSpec;
-    /** Operation index → the `resultPath` it writes (index 0 = root `$`). */
-    readonly resultPaths: readonly string[];
-}
-
-interface QueryOptions {
-    consistentRead?: boolean;
-    maxDepth?: number;
-    /**
-     * Per-call throttle / transient-error retry override (issue #111), applied to the
-     * parent read AND to every relation-fan-out send under it. A {@link RetryPolicy}
-     * replaces the global policy for this call; `false` disables retry. Omit to use
-     * the configured (or built-in default) policy.
-     */
-    retry?: RetryOverride;
-    /**
-     * When `true`, the returned item carries its resolved base-table key as a
-     * non-enumerable Symbol property so it can be passed back to `update()`
-     * directly — even for a partial `select` or a GSI-based query. Host-side
-     * runtime behaviour only; not part of the serialized query.
-     */
-    updatable?: boolean;
-    /**
-     * Opt-in class / domain-object hydration (issue #53). When provided, the
-     * factory is applied as the **final after-fetch step** to the fully-built
-     * plain object (after projection, relation resolution, and any `updatable`
-     * hidden-key attachment) and its return value is what the read resolves to —
-     * the return type propagates from the factory (see `ModelStatic.query`).
-     *
-     * Semantics:
-     * - applied to a **present** item only; a `null` read stays `null` and the
-     *   factory is NOT invoked, so the factory need not be null-tolerant;
-     * - a throw from the factory propagates verbatim as the read's rejection
-     *   (the fetch already succeeded; the failure is purely in caller code);
-     * - synchronous by design — an async transform is a caller-side `await` on
-     *   the plain result, intentionally out of scope here.
-     *
-     * Host-side runtime behaviour ONLY: like `updatable` / `consistentRead`, the
-     * factory is a host-language closure that is NEVER serialized into the SSoT /
-     * `operations.json`, so it does not impede the multi-language bridge (#48).
-     * "What to fetch" stays declarative; "what object to load it onto" is host-side.
-     */
-    hydrate?: (raw: Record<string, unknown> | null) => unknown;
-    /**
-     * Host-injected per-call read context (issue #50 / #138) — exposed to every
-     * read hook (R1–R5) as `ctx.context`, and threaded UNCHANGED to every relation
-     * fan-out op so a hook (e.g. a tenant-scope R2 filter) applies across the root
-     * read AND the fan-out fetches. A host-language value, NEVER serialized into the
-     * SSoT / `operations.json` (the bridge #48 is unaffected). Absent ⇒ `{}`.
-     */
-    context?: RequestContext;
-}
-declare function executeQuery(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: QueryOptions): Promise<Record<string, unknown> | null>;
-
-interface ListInput {
-    limit?: number;
-    after?: string;
-    order?: 'ASC' | 'DESC';
-    /** Declarative server-side DynamoDB FilterExpression input. */
-    filter?: Record<string, unknown>;
-    /**
-     * When `true`, each returned item carries its resolved base-table key as a
-     * non-enumerable Symbol property so it can be passed back to `update()`
-     * directly. Host-side runtime behaviour only; not part of the serialized
-     * query.
-     */
-    updatable?: boolean;
-    /**
-     * Per-call throttle / transient-error retry override (issue #111). A
-     * {@link RetryPolicy} replaces the global policy for this read; `false` disables
-     * retry. Omit to use the configured (or built-in default) policy.
-     */
-    retry?: RetryOverride;
-    /**
-     * Host-injected per-call read context (issue #50 / #138) — exposed to every
-     * read hook as `ctx.context`. Used only when this `list` is the read ENTRY
-     * point (the public `DDBModel.list` / a `list` envelope route): a fresh
-     * {@link MiddlewareRuntime} is built from it. Ignored when a relation fan-out
-     * threads an already-built {@link mw} (the runtime then carries the root read's
-     * context). Absent ⇒ `{}`.
-     */
-    context?: RequestContext;
-    /**
-     * @internal The per-read middleware runtime, threaded UNCHANGED from a relation
-     * fan-out (issue #138) so the hasMany Query's op-level hooks (R2/R3/R5) fire
-     * with the root read's context + the fan-out's {@link relationPath}. When absent
-     * at the entry point, one is built from {@link context}.
-     */
-    mw?: MiddlewareRuntime;
-    /**
-     * @internal The relation path to THIS list read — `[]` (or absent) for a
-     * top-level `list`; the fan-out leg (e.g. `['orders']`) for a hasMany Query.
-     * Populates the op-level ctx's `relationPath` (issue #138).
-     */
-    relationPath?: readonly string[];
-}
-/**
- * Public list result returned by `DDBModel.list()`. Contains exactly the
- * `items` and `cursor` keys — no `rawItems` leak.
- */
-interface ListResult {
-    items: Record<string, unknown>[];
-    cursor: string | null;
-}
-/**
- * Public list execution backing `DDBModel.list()`. Delegates to
- * {@link executeListInternal} and constructs a fresh result object exposing
- * only `{ items, cursor }`, so internal-only fields such as `rawItems` never
- * cross the public API boundary (no reliance on `as` type narrowing).
- */
-declare function executeList(modelClass: Function, key: Record<string, unknown>, selectSpec: Record<string, unknown>, options?: ListInput): Promise<ListResult>;
-
-declare function derivePrefix(customPrefix: string | undefined, className: string | undefined): string;
-
-/**
- * Validate that no two access patterns (PK + GSIs) have overlapping
- * input field sets. A subset relationship means a single query input
- * could match multiple access patterns, creating ambiguity.
- */
-declare function validateGsiAmbiguity(primaryKey: KeyDefinition | null, gsiDefinitions: GsiDefinition[]): void;
-
 interface ModelOptions {
     table: string;
     prefix?: string;
@@ -734,8 +333,8 @@ type ProjectionValue = SourceRef | ProjectionTransform;
  * multi-source view (different sources filling DIFFERENT fields) is fine.
  */
 
-type AnyModelClass$1 = new (...args: any[]) => any;
-type SourceFactory = () => AnyModelClass$1;
+type AnyModelClass = new (...args: any[]) => any;
+type SourceFactory = () => AnyModelClass;
 /**
  * A map keyed by `keyof Self` (the typed view fields) with value type `V`. When
  * `Self` is left at its `unknown` default (the un-annotated decorator), it widens to
@@ -1066,1145 +665,21 @@ declare function max(field: string): AggregateValue;
  */
 declare function cdcProjected(): (_target: Function, _context: ClassDecoratorContext) => void;
 
-declare class TableMapping {
-    private static mapping;
-    static set(mapping: Record<string, string>): void;
-    static resolve(declaredName: string): string;
-    /** @internal — for testing only */
-    static reset(): void;
-}
-
-/** Type guard: is this select-position value a builder rather than a plain spec? */
-declare function isSelectBuilder(value: unknown): value is SelectBuilderSpec;
-
-interface UpdateExpressionResult {
-    expression: string;
-    names: Record<string, string>;
-    values: Record<string, unknown>;
-}
-declare function buildUpdateExpression(changes: Record<string, unknown>, embeddedFieldNames: Set<string>): UpdateExpressionResult;
-
-interface ConditionExpressionResult {
-    expression: string;
-    names: Record<string, string>;
-    values: Record<string, unknown>;
-}
-
-declare function buildConditionExpression(condition: Record<string, unknown> | RawCondition): ConditionExpressionResult;
-
-/**
- * Compiled DynamoDB `FilterExpression`. Names are `#`-aliased column
- * placeholders (collision-free, refactor-safe) and values are `:`-aliased
- * parameters — there is no literal interpolation, so the compiler is injection
- * free. This result is attached to a Query/Scan operation independently of the
- * KeyConditionExpression and ProjectionExpression.
- */
-interface FilterExpressionResult {
-    filterExpression: string;
-    expressionAttributeNames: Record<string, string>;
-    expressionAttributeValues: Record<string, unknown>;
-}
-/**
- * Compile a declarative {@link FilterInput} object into a DynamoDB
- * `FilterExpression` with parameterized values and aliased column names.
- *
- * Multiple top-level field keys are joined with implicit `AND`. Returns
- * `undefined` for an empty / no-op filter so callers can skip attaching it.
- */
-declare function compileFilterExpression(filter: Record<string, unknown> | undefined, metadata: EntityMetadata): FilterExpressionResult | undefined;
-/**
- * Evaluate a {@link FilterInput} against an already-hydrated item, client-side.
- *
- * Used for belongsTo / hasOne relations, which resolve via `BatchGetItem` and
- * therefore cannot push a server-side `FilterExpression`. Operates on the
- * fields present on the item (compared with hydrated TS values, e.g. `Date`).
- */
-declare function evaluateFilter(item: Record<string, unknown>, filter: Record<string, unknown>): boolean;
-
-/**
- * Declarative transaction executor (issue #46, Python-bridge Phase 4).
- *
- * Executes a serializable {@link TransactionSpec} against DynamoDB by expanding
- * its templated items with concrete params and an optional array of `forEach`
- * elements, deriving each row's key (and GSI) attributes from the manifest, and
- * issuing **one** `TransactWriteItems` (≤25). This is the bridge-side, fully
- * declarative counterpart to the ergonomic `executeTransaction` (the latter
- * stays as the TS-only imperative API). Both the TS path here and the Python
- * runtime expand the spec by the **same** rules, which the conformance harness
- * verifies end-to-end.
- *
- * Template forms (mirroring the planner): `{param}` resolves from the caller
- * params; `{item.<field>}` resolves from the current `forEach` element. A leaf
- * with no placeholder is a literal.
- */
-
-/** A `{ Put | Update | Delete }` entry as accepted by `TransactWriteCommand`. */
-type TransactItem = Record<string, unknown>;
-/**
- * Expand a {@link TransactionSpec} into the concrete `TransactItems` list for a
- * given set of params. Each item with a `forEach` binding is expanded once per
- * element of the named array param (skipping elements whose `when` fails); a
- * plain item is emitted once (skipping it when its `when` fails). After expansion
- * the items are collapsed op-aware ({@link collapseSameKeyItems}) by the SINGLE shared
- * {@link import('../runtime/same-key-collapse.js').collapseSameKey} rule the in-process
- * runtime and the Python `TransactionExpander` apply identically: a swap pair that resolved
- * to one physical key becomes a net no-op, a self-row Put/Delete de-dups, same-key counter
- * ADDs merge, and a `Put`+`Update` (an aliased self-target counter, #93) — or any other
- * unsupported same-key combination — is REJECTED loudly rather than silently dropped, so the
- * same SSoT cannot diverge. The ≤25 limit is checked here too (mirroring Python's
- * `TransactionExpander.expand`); {@link commitTransaction} re-checks it as the runtime guard.
- */
-declare function expandTransaction(spec: TransactionSpec, manifest: Manifest, params: Record<string, unknown>): TransactItem[];
-/**
- * Execute a declarative transaction spec with concrete params against DynamoDB (issue #46).
- *
- * Routes through the SINGLE shared {@link commitTransaction} orchestration (issue #97): the
- * expanded items are collapsed op-aware, capped at ≤25 (a transaction is atomic — never
- * split), committed atomically, and fed POST-COMMIT into the in-process change-capture seam
- * (issue #72 / #94) — so a declarative transaction now emits ChangeEvents just like every
- * other transaction path (the original #97 goal), with each modeled row labelled by its
- * entity and the `literalKey` marker rows captured unlabelled for the emulator's table-level
- * fallback. A no-op (zero expanded items) issues no call; a rolled-back transaction throws
- * before the capture step and emits ZERO events.
- */
-declare function executeDeclarativeTransaction(spec: TransactionSpec, manifest: Manifest, params: Record<string, unknown>): Promise<void>;
-
-interface ExplainInput {
-    select?: Record<string, unknown>;
-    limit?: number;
-    after?: string;
-    order?: 'ASC' | 'DESC';
-    consistentRead?: boolean;
-    filter?: Record<string, unknown>;
-}
-declare function executeExplain(modelClass: Function, key: Record<string, unknown>, options?: ExplainInput): ExecutionPlan;
-
-declare function serializeFieldValue(value: unknown, fieldMeta: FieldMetadata): unknown;
-
-declare function resolveKey(queryFields: string[], metadata: EntityMetadata): ResolvedKey;
-
-interface ProjectionResult {
-    projectionExpression: string;
-    expressionAttributeNames: Record<string, string>;
-}
-/**
- * Builds ProjectionExpression and ExpressionAttributeNames from a select object.
- *
- * Rules:
- * - scalar (`true`) → field name added to projection
- * - inline embeddedSnapshot read (`{ inline: true }`, issue #196) → the owner-row
- *   physical attribute is added to the projection like a scalar (the maintained
- *   copy is read straight off the row, NOT traversed to child partitions)
- * - embedded (object without `select`/`inline`) → nested path e.g. `#p0.#p1`
- * - relation (object with `select` property) → excluded from projection
- * - additionalFields → added to projection (for implicit key resolution)
- */
-declare function buildProjection(select: Record<string, unknown>, additionalFields?: string[]): ProjectionResult | undefined;
-
-interface PlanInput {
-    key: Record<string, unknown>;
-    select: Record<string, unknown>;
-    limit?: number;
-    after?: Record<string, unknown>;
-    order?: 'ASC' | 'DESC';
-    consistentRead?: boolean;
-    additionalProjectionFields?: string[];
-    /** Declarative server-side filter (compiled to a FilterExpression). */
-    filter?: Record<string, unknown>;
-    /**
-     * When `true`, the base-table key attributes (`PK`/`SK`) are added to the
-     * ProjectionExpression so the hydrator can carry a resolved key on the result
-     * (issue #54). Required for partial-`select` and GSI-based reads, where the
-     * key would otherwise not be returned.
-     */
-    updatable?: boolean;
-}
-declare function plan(metadata: EntityMetadata, input: PlanInput): ExecutionPlan;
-
-/**
- * Execute a structured read operation through the active I/O seam (issue #76).
- *
- * This is the read entry point the planner-driven paths (`query` / `list`) call.
- * It delegates to `ClientManager.getExecutor()`, which is the default
- * {@link import('./retrying-executor.js').RetryingExecutor}-wrapped
- * {@link import('./dynamo-executor.js').DynamoExecutor} unless a test has injected
- * a `MemoryExecutor` via `ClientManager.setExecutor()`. The optional
- * {@link ReadExecOptions} carries a per-call retry override (issue #111).
- */
-declare function execute(operation: DynamoDBOperation, options?: ReadExecOptions): Promise<ExecutorResult>;
-
-/**
- * The default {@link Executor}: a thin, behavior-preserving move of GraphDDB's
- * original DynamoDB I/O behind the unified seam (issue #76). Each method builds
- * exactly the AWS SDK command the corresponding operation built before the
- * refactor and sends it through `ClientManager.getDocumentClient()`, so the
- * command shapes (and therefore every existing mock-based / integration test)
- * are unchanged.
- *
- * The optional per-call options (`ReadExecOptions` / `BatchExecOptions`) carry a
- * retry override (issue #111) that is meaningful ONLY to {@link RetryingExecutor};
- * here they are accepted to satisfy the {@link Executor} interface and otherwise
- * ignored (this executor performs no app-level error retry of its own).
- */
-declare class DynamoExecutor implements Executor {
-    execute(operation: DynamoDBOperation, _options?: ReadExecOptions): Promise<ExecutorResult>;
-    batchGet(input: BatchGetExecInput, _options?: ReadExecOptions): Promise<ExecutorResult>;
-    put(input: PutInput, options?: WriteExecOptions): Promise<WriteResult>;
-    update(input: UpdateInput, options?: WriteExecOptions): Promise<WriteResult>;
-    delete(input: DeleteInput, options?: WriteExecOptions): Promise<WriteResult>;
-    batchWrite(tableName: string, items: BatchWriteExecItem[], _options?: BatchExecOptions): Promise<void>;
-    transactWrite(items: TransactWriteExecItem[], _options?: BatchExecOptions): Promise<void>;
-}
-
-/**
- * {@link RetryingExecutor} — the single-op throttle / transient-error retry layer
- * (issue #111). It DECORATES an inner {@link Executor} (the default
- * {@link DynamoExecutor}), wrapping every single-op send — `execute` (Get/Query),
- * `batchGet` (relation fan-out + planner reads), `put` / `update` / `delete`, and
- * `transactWrite` — in {@link runWithRetry} so a throttle / transient error is
- * retried with exponential backoff + jitter under a bounded attempt cap.
- *
- * This is the (B) ERROR-retry layer; the (A) partial-batch retry
- * (`UnprocessedKeys` / `UnprocessedItems`) lives inside `batchGet` / `batchWrite`
- * and is a SEPARATE concern (see `retry-policy.ts` header). The two share the
- * backoff function but never merge:
- *  - `batchGet` here gets an OUTER error-retry wrap (the inner BatchGet still does
- *    its own UnprocessedKeys retry; the outer wrap catches a hard throttle REJECT
- *    of the whole send).
- *  - `batchWrite` is the in-flight bulk path that already owns UnprocessedItems
- *    retry per chunk; it is passed through UNWRAPPED here to avoid double-counting
- *    a throttle as both an unprocessed-item retry and an error retry. (Its chunks
- *    already back off on the shared ramp.)
- *
- * The policy precedence per call: an explicit per-call override (`retry:` on the
- * option bag) wins; otherwise the globally-configured policy
- * (`DDBModel.setRetryPolicy`); otherwise the always-on {@link DEFAULT_RETRY_POLICY}.
- * `retry: false`, or a resolved `maxAttempts <= 1`, disables retry for that call.
- */
-
-declare class RetryingExecutor implements Executor {
-    private readonly inner;
-    private readonly getGlobalPolicy;
-    /**
-     * @param inner the wrapped executor (the real {@link DynamoExecutor}).
-     * @param getGlobalPolicy reads the globally-configured policy (or `null` for the
-     *   built-in default) at CALL time, so a `DDBModel.setRetryPolicy(...)` after the
-     *   executor is constructed still takes effect.
-     */
-    constructor(inner: Executor, getGlobalPolicy: () => RetryPolicy | null);
-    execute(operation: DynamoDBOperation, options?: ReadExecOptions): Promise<ExecutorResult>;
-    batchGet(input: BatchGetExecInput, options?: ReadExecOptions): Promise<ExecutorResult>;
-    put(input: PutInput, options?: WriteExecOptions): Promise<WriteResult>;
-    update(input: UpdateInput, options?: WriteExecOptions): Promise<WriteResult>;
-    delete(input: DeleteInput, options?: WriteExecOptions): Promise<WriteResult>;
-    batchWrite(tableName: string, items: BatchWriteExecItem[], options?: BatchExecOptions): Promise<void>;
-    transactWrite(items: TransactWriteExecItem[], options?: BatchExecOptions): Promise<void>;
-}
-
-/**
- * Transforms raw DynamoDB items into partial Entity objects.
- *
- * - Applies type conversions (ISO 8601 → Date for `format: 'datetime'`)
- * - Reconstructs embedded objects from Map attributes
- * - Returns only the fields named in `select`; internal `PK`/`SK`/GSI key
- *   attributes are never copied into the result (not actively stripped)
- *
- * When `updatable` is `true`, each result additionally carries its already
- * resolved base-table key (`{ PK, SK }`) as a non-enumerable Symbol property
- * (see {@link attachHiddenKey}) so it can be passed straight back to `update()`
- * even for a partial `select` or a GSI-based read. This is invisible to
- * `JSON.stringify` / `Object.keys` / spread.
- */
-declare function hydrate(rawItems: Record<string, unknown>[], select: Record<string, unknown>, metadata: EntityMetadata, updatable?: boolean): Record<string, unknown>[];
-
-/**
- * Encodes a DynamoDB LastEvaluatedKey into a base64url cursor string.
- */
-declare function encodeCursor(lastEvaluatedKey: Record<string, unknown>): string;
-/**
- * Decodes a base64url cursor string back into a DynamoDB ExclusiveStartKey.
- */
-declare function decodeCursor(cursor: string): Record<string, unknown>;
-
-/**
- * Per-key cursor envelope for batched `range` (`list`) contract methods (issue
- * #62, CQRS single-service runtime; spec `docs/cqrs-contract.md`,
- * "Pagination under batch + list").
- *
- * A `range` contract method paginates **per key**: each key owns its own
- * connection and therefore its own pagination position. The proposal requires
- * that "the cursor envelope must carry the key it belongs to" so a caller can
- * never accidentally resume one key's pagination against another key.
- *
- * This module wraps the **inner** page cursor (the base64url-encoded DynamoDB
- * `LastEvaluatedKey` produced by {@link encodeCursor}) together with a **stable
- * identity of the owning key** into a single opaque envelope. The envelope is
- * itself base64url-encoded so it round-trips through a URL / JSON body exactly
- * like the inner cursor it supersedes — callers treat it as the same opaque
- * string and pass it back as `params.after`.
- *
- * ## Why even the single-key range form is wrapped
- *
- * The proposal frames per-key cursors under "batch + list", but a single `range`
- * method (`inputArity: 'single'`) is the only externally reachable range form
- * for a single contract (see {@link executeQueryMethod} — a `range` method
- * rejects an array by construction). Wrapping the single-key form too keeps the
- * cursor shape **uniform**: a `range` connection always carries a key-bound
- * envelope, so cursor handling does not branch on input arity and the runtime
- * can always validate that a supplied `after` belongs to the key being read.
- *
- * ## Key identity
- *
- * The owning key is serialized with {@link serializeContractKey} — a canonical,
- * field-sorted JSON form that is **byte-identical across TS and Python** (the
- * parity foundation conformance #65 will lock). The envelope stores this string,
- * not the raw key object, so two structurally-equal keys (field order aside)
- * resume the same pagination.
- */
-/**
- * The decoded contents of a per-key cursor envelope: the canonical key identity
- * it belongs to ({@link serializeContractKey}) and the inner page cursor (the
- * base64url DynamoDB `LastEvaluatedKey`).
- */
-interface PerKeyCursorEnvelope {
-    /** The canonical serialized identity of the key this cursor paginates. */
-    readonly key: string;
-    /** The inner page cursor (base64url-encoded `LastEvaluatedKey`). */
-    readonly inner: string;
-}
-/**
- * Canonical, cross-runtime-stable string identity of a contract key. Object
- * fields are sorted by name so `{ a, b }` and `{ b, a }` serialize identically;
- * values are emitted as compact JSON, matching the Python runtime's
- * `serialize_contract_key` (sorted items, compact separators). This is the
- * identity used to key a batch result map and to bind a per-key cursor.
- *
- * **#253 adapter (behavior-contracts)**: this is the shared COMMON
- * `canonicalValue` primitive (runtime-boundary.md §2.1 →
- * canonical-serialization.md §2: key identity = top-level key sort + compact
- * JSON), the same delegation the Python / Rust / Go runtimes adopted in #255.
- * graphddb's former field-sorted `JSON.stringify` is deleted; plain JS key
- * values cross the boundary through {@link toSharedValue} (integral `number` →
- * shared int, `Date` → ISO string, `undefined` fields dropped — the exact
- * `JSON.stringify` semantics the old implementation had). Byte identity of the
- * output is locked by the frozen #253 conformance golden.
- *
- * @param key A plain contract-key object (e.g. `{ categoryId: 'tech' }`).
- * @returns A deterministic JSON string, e.g. `{"categoryId":"tech"}`.
- */
-declare function serializeContractKey(key: Record<string, unknown>): string;
-/**
- * Build a per-key cursor envelope from the owning key and an inner page cursor,
- * encoded as a single opaque base64url string. Returns `null` when `inner` is
- * `null` (the key has no further pages — a terminal connection has a `null`
- * cursor, never an envelope wrapping nothing).
- *
- * @param key   The contract key this page belongs to.
- * @param inner The inner page cursor, or `null` when the connection is exhausted.
- */
-declare function encodePerKeyCursor(key: Record<string, unknown>, inner: string | null): string | null;
-/**
- * Decode a per-key cursor envelope produced by {@link encodePerKeyCursor}, and
- * **verify** it belongs to `expectedKey`. A cursor minted for one key fed back
- * for another is a caller error (it would silently resume the wrong key's
- * pagination), so it is rejected rather than honored.
- *
- * @param cursor      The opaque envelope string (a `params.after` value).
- * @param expectedKey The key currently being read; the envelope must match it.
- * @returns The inner page cursor to hand to the underlying `list`.
- * @throws if the envelope is malformed, or its key identity does not match
- *   `expectedKey`.
- */
-declare function decodePerKeyCursor(cursor: string, expectedKey: Record<string, unknown>): string;
-
-/**
- * Static prepared-plan LOADER (issue #208) — the runtime half of the AOT
- * pipeline. `graphddb transform prepared --aot` compiles every verified
- * `DDBModel.prepare` body at BUILD time into a {@link PreparedPlanDocument}
- * (`src/spec/prepared.ts`) and rewrites the call site to
- *
- * ```ts
- * (__gddbPrepared1 ??= loadPreparedPlan(__gddbPreparedPlans, '<id>', ($) => ({…})))
- * ```
- *
- * This module loads that artifact: it re-binds each plan's entity NAMES against
- * the live {@link MetadataRegistry}, verifies the plan is not stale, and returns
- * a handle whose `execute` runs the very same execution cores the runtime
- * `prepare` uses — with **zero plan construction / compilation per op, including
- * the first call**:
- *
- * - a **read** plan binds into the SAME {@link PreparedReadStatement} the
- *   runtime `prepare` returns (identical semantics by construction — reads never
- *   had an expensive compile; what `prepare` computes once, the artifact
- *   carries);
- * - a **write** plan's mutation compile (lifecycle resolution + derived-effect
- *   derivation — the expensive half) happened at BUILD time; `execute` renders
- *   the serialized templates and runs {@link executeLogicalWriteOps} /
- *   {@link executeLogicalParallelWrites} — the same W1–W5 / fast-path / atomic
- *   commit / read-back pipeline as the compiled core, so effects are identical.
- *
- * ## Stale plans are a LOUD reject
- *
- * Each plan records a fingerprint of every entity's canonical manifest entry at
- * build time. On first use the loader recomputes the fingerprints from the live
- * registry: a mismatch (the model declarations — key/GSI templates, fields,
- * relations, table mapping — changed since the artifact was generated) throws
- * with a regeneration hint. A stale static plan NEVER executes. Version-skewed
- * artifacts (format / spec IR version) reject the same way.
- *
- * ## Laziness
- *
- * Binding is deferred to the FIRST `execute` (not the `loadPreparedPlan` call):
- * a module-scope `const p = loadPreparedPlan(…)` must not touch the registry at
- * module-init time (the target models may be declared later in the same module —
- * the same TDZ hazard the #206 lazy slot solves). Binding is memoized per
- * `(document, planId)`; it performs registry lookups + fingerprint hashing only,
- * never plan compilation.
- */
-
-interface BoundWriteOp {
-    readonly alias: string;
-    readonly spec: PreparedWriteOpSpec;
-    readonly modelClass: Function;
-    readonly modelStatic: ModelStatic<DDBModel>;
-    readonly keySlots: Readonly<Record<string, Slot>>;
-    readonly inputSlots: Readonly<Record<string, Slot>>;
-    readonly conditionSlots?: Readonly<Record<string, Slot>>;
-    readonly manifest: Manifest;
-}
-/** A prepared WRITE handle bound from a static plan (#208). `execute(params)`
- * mirrors {@link import('./prepared.js').PreparedWriteStatement.execute}. */
-declare class AotPreparedWriteStatement {
-    private readonly ops;
-    /** @internal */
-    constructor(ops: readonly BoundWriteOp[]);
-    execute(params?: Record<string, unknown>, options?: PreparedWriteExecOptions): Promise<Record<string, CommandReturn | undefined> | Record<string, ParallelOpResult | ParallelOpResult[]>>;
-}
-/**
- * Load one statically-compiled prepared plan (issue #208). The rewritten call
- * site passes the artifact document, the stable plan id, and the ORIGINAL
- * prepare body — the body is retained in source as the plan's compile source
- * (drift regeneration + type inference + the untransformed-build fallback) and
- * is NEVER evaluated here: execution consumes the static artifact only.
- *
- * Per-op plan construction / compilation is ZERO, including the first call —
- * the first `execute` performs registry binding + stale-fingerprint
- * verification only (memoized per `(document, planId)`), then every call binds
- * params into the frozen plan and runs the shared execution cores.
- */
-declare function loadPreparedPlan(doc: PreparedPlanDocument, planId: string, body?: PreparedBody): PreparedStatement;
-
-declare function detectRelationFields(select: Record<string, unknown>, metadata: EntityMetadata): RelationMetadata[];
-declare function getImplicitKeyFields(select: Record<string, unknown>, metadata: EntityMetadata): string[];
-
-interface RelationTraversalOptions {
-    maxDepth?: number;
-    /**
-     * When `true`, each resolved single-result relation (`belongsTo` / `hasOne`)
-     * and each `hasMany` item carries its resolved base-table key as a
-     * non-enumerable Symbol property so it can be passed back to `update()`.
-     */
-    updatable?: boolean;
-    /**
-     * Per-call throttle / transient-error retry override (issue #111), threaded from
-     * the read's entry point into every relation-fan-out send (the `BatchGet` for
-     * `belongsTo` / `hasOne`, the `Query` for `hasMany`). A {@link RetryPolicy}
-     * replaces the global policy; `false` disables retry. Threaded unchanged through
-     * every recursion level.
-     */
-    retry?: RetryOverride;
-    /**
-     * The **declared execution plan** (issue #70c) the traversal HONORS to decide
-     * which sibling relations are independent (a concurrency-eligible stage) and the
-     * in-flight bound. It is built once at the read's entry point from the live
-     * `select` tree via {@link buildRelationExecutionPlan} — the *same*
-     * {@link deriveExecutionPlan} the SSoT generator runs — and threaded, unchanged,
-     * through every recursion level. The traversal reads its grouping/bound from
-     * this plan; it never re-decides "parallelize every sibling".
-     *
-     * Absent → {@link resolveRelations} builds it from `(select, metadata)` at the
-     * top level (the normal host-runtime path) and threads it down. A direct caller
-     * (or a test proving the plan is honored) may inject a plan with a different
-     * grouping / bound and observe the traversal execute accordingly.
-     */
-    plan?: RelationExecutionPlan;
-    /**
-     * The per-read middleware runtime (issue #50 / #138), threaded UNCHANGED from
-     * the read's entry point into every relation fan-out fetch — exactly like
-     * `retry`. Each fan-out send is wrapped so the op-level hooks R2 (before send) /
-     * R3 (raw items) / R5 (op error) fire for that physical op too, with
-     * `ctx.relationPath` identifying the fan-out leg (`['orders']`,
-     * `['orders','product']`, …) and `ctx.model` the relation's target model.
-     * Absent → {@link NO_MIDDLEWARE} (no hooks).
-     */
-    mw?: MiddlewareRuntime;
-    /**
-     * The relation path from the root read to the CURRENT traversal level — `[]`
-     * at the root, extended by each relation's property name as the traversal
-     * recurses. Used only to populate `ctx.relationPath` for the op-level hooks
-     * (R2/R3/R5). Threaded alongside {@link mw}.
-     */
-    relationPath?: readonly string[];
-}
-/**
- * Validates that the select depth does not exceed maxDepth.
- * Throws a runtime error if depth is exceeded.
- */
-declare function validateDepth(select: Record<string, unknown>, metadata: EntityMetadata, maxDepth: number, currentDepth?: number): void;
-/**
- * Resolves all relation fields for a single parent item, HONORING the declared
- * execution plan (issue #70c). Returns the merged result with relations attached.
- *
- * The grouping of sibling relations into concurrency-eligible stages and the
- * in-flight bound come from the serialized {@link RelationExecutionPlan} — the
- * *same* plan the SSoT generator derives (`src/relation/execution-plan.ts`), so
- * the TS host runtime and the Python runtime make identical, plan-declared
- * parallelism decisions. The plan is built once from the live `select` tree at the
- * read's entry (when `options.plan` is absent) and threaded, unchanged, through
- * every recursion level; `currentPath` tracks which parent level this call
- * resolves so each relation's declared stage is looked up by its `resultPath`.
- *
- * For a faithfully-built plan the direct children of one parent path share a
- * stage (the generator's level-by-level layering), so they run as one concurrent
- * group under the declared bound — byte-equivalent to the pre-#70c "parallelize
- * siblings" fan-out. A *declared* plan with different grouping / bound changes the
- * schedule accordingly: the plan is honored, never re-derived.
- *
- * @param currentPath The parent result path this call resolves relations under
- *   (`$` at the root; `$.<prop>.items` / `$.<prop>` for nested levels). Used to
- *   locate each relation's declared stage in the plan.
- */
-declare function resolveRelations(parentItem: Record<string, unknown>, rawParentItem: Record<string, unknown>, select: Record<string, unknown>, metadata: EntityMetadata, options: RelationTraversalOptions, currentDepth?: number, currentPath?: string): Promise<Record<string, unknown>>;
-
-/**
- * Edge write-effects: derive the adjacency `Put` / `Delete` transaction items
- * that materialize a relation edge on DynamoDB (issue #82, Epic #80).
- *
- * ## What an "edge" is here, and what "writing" it means
- *
- * The read side (`src/relation/traversal.ts`, `src/planner/relation-planner.ts`)
- * resolves a `@hasMany` / `@belongsTo` / `@hasOne` relation by reading an
- * **adjacency entity** — a base-table row whose key is built from the foreign-key
- * fields the relation binds on (the `keyBinding`). In the canonical
- * user-permissions model a `GroupMembershipModel` row IS the edge between a
- * `User` and a `Group`: `Group.members` (`@hasMany`, `{ groupId: 'groupId' }`)
- * reads it on the base PK (`GROUP#{groupId}` / `USER#{userId}`), and
- * `User.groups` (`@hasMany`, `{ userId: 'userId' }`) reads the **same row** on
- * the inverse GSI (`USER#{userId}` / `GROUP#{groupId}`). One physical row, two
- * read directions: the inverse GSI is auto-maintained by DynamoDB from the base
- * row's attributes, so there is nothing extra to write for the second direction.
- *
- * Therefore the **write side of an edge is one base-table row**:
- *
- * - **onCreate** — `Put` that row. Its key (PK/SK) is derived from the adjacency
- *   entity's own {@link SegmentedKey}, so the row the writer emits is *exactly*
- *   the row the existing read traversal queries: the round-trip is correct **by
- *   construction**, not by coincidence.
- * - **onDelete** — `Delete` that same row, keyed by the same PK/SK.
- * - **onUpdateKeyChange** — when a foreign key the edge keys on changes (e.g.
- *   `post.userId` moves a Post to a different owner), the edge **moves**: the old
- *   row must be `Delete`d and the new row `Put`. Delete/update need the **old**
- *   key value, which the single-row create form never carries — see
- *   {@link OLD_VALUE_NAMESPACE}.
- *
- * ## Declaration is additive
- *
- * An edge's write side is declared on the adjacency entity (the entity whose row
- * *is* the edge) via {@link edgeWrites}; it references, by `() => TargetModel` +
- * relation property name, the read-side relation(s) the row satisfies. The
- * declaration is **purely additive** — it adds a static `writes` member and
- * touches no field/relation/key metadata — so existing models and generated
- * fixtures stay byte-identical, and the read traversal is unaffected.
- *
- * ## Output is the existing SSoT
- *
- * Derivation produces {@link TransactionItemSpec} items — the *same*
- * JSON-serializable shape `defineTransaction` emits (`src/spec/transaction.ts`)
- * — so a derived edge `Put` / `Delete` slots into a `TransactWriteItems` with no
- * new execution substrate. Wiring these into the mutation compiler / transaction
- * assembly is a later issue (#85); this module is the derivation primitive only.
- */
-
-/**
- * The template namespace for an edge's **old** foreign-key value, used by the
- * `onUpdateKeyChange` Delete(old) item. Where a create/put keys on `{field}`
- * (the post-write value, from the mutation input / written entity), the
- * delete-of-old keys on `{old.field}`. This makes the source of each value
- * unambiguous in the serialized spec and lets a single transaction carry **both**
- * the old key (to delete the stale edge) and the new key (to put the moved edge)
- * without collision.
- *
- * How the old value is obtained is the caller's (the #85 compiler's) concern and
- * is intentionally out of scope here: it is threaded in as a normal transaction
- * param named `old.<field>`, exactly as the existing transaction runtime resolves
- * any `{param}` placeholder (`src/operations/declarative-transaction.ts` /
- * `python/graphddb_runtime/transactions.py`). The proposal's recommended source
- * is the pre-mutation entity image (`$.entity.*` — a read of the row before the
- * write, or the DynamoDB old image); this module only fixes the *token shape* so
- * the two key images never clash.
- */
-declare const OLD_VALUE_NAMESPACE: "old";
-/** The lifecycle phase an edge write effect is derived for. */
-type EdgeLifecycle = 'onCreate' | 'onDelete' | 'onUpdateKeyChange';
-/**
- * One declared edge write effect on an adjacency entity: the read-side relation
- * (on a target model) that this entity's row materializes. The declaration is
- * lifecycle-agnostic — the *same* edge is created on create, deleted on delete,
- * and moved on a foreign-key change; {@link deriveEdgeWriteItems} fans it out
- * into the three lifecycle forms.
- *
- * ## `inverse` — dual-edge synchronization (Epic #118 pattern 9, issue #133)
- *
- * The plain edge above is **one physical row** that serves *both* read directions:
- * the base PK reads one direction and an inverse GSI (auto-maintained by DynamoDB)
- * reads the other, so a bidirectional relation costs a single write. The RFC §1
- * pattern-9 gap is the case where the inverse direction is NOT served by that GSI
- * but by a **second physical row** on its own partition — the genuine *dual edge*
- * (forward + inverse rows). {@link inverse}, when present, names a SECOND adjacency
- * model + relation property whose row is the inverse edge; {@link
- * deriveEdgeWriteItemsFor} then maintains BOTH rows from this single (one-direction)
- * declaration — the create `Put`s both, the delete `Delete`s both, a foreign-key
- * change `Delete`s+`Put`s both — so the two directions can never drift. Omit
- * `inverse` for the historical single-row-plus-GSI bidirectional edge.
- */
-interface EdgeWriteDeclaration {
-    /** Resolves the target model whose relation this edge feeds (e.g. `GroupModel`). */
-    readonly targetFactory: () => new (...args: unknown[]) => unknown;
-    /** The relation property on the target that reads this edge (e.g. `members`). */
-    readonly relationProperty: string;
-    /**
-     * The INVERSE edge to keep in sync (Epic #118 pattern 9 / issue #133, dual-edge).
-     * Names the second adjacency model whose own row materializes the reverse-direction
-     * relation. When present, every lifecycle derivation maintains the inverse row
-     * alongside the forward row in the SAME transaction, so a one-direction declaration
-     * keeps a two-row bidirectional edge consistent. Absent = the historical single-row
-     * (base + inverse GSI) bidirectional edge.
-     */
-    readonly inverse?: {
-        /** Resolves the inverse adjacency model whose row IS the inverse edge. */
-        readonly adjacencyFactory: () => new (...args: unknown[]) => unknown;
-        /** Resolves the target model whose relation the inverse row feeds. */
-        readonly targetFactory: () => new (...args: unknown[]) => unknown;
-        /** The relation property on the inverse target that reads the inverse row. */
-        readonly relationProperty: string;
+declare const graphddb: {
+    readonly publishQuery: typeof publishQuery;
+    readonly publishCommand: typeof publishCommand;
+    readonly query: typeof DDBModel.query;
+    readonly mutate: typeof DDBModel.mutate;
+    readonly prepare: typeof DDBModel.prepare;
+    readonly subscribe: typeof DDBModel.subscribe;
+    readonly config: {
+        readonly client: (client: _aws_sdk_client_dynamodb.DynamoDBClient) => void;
+        readonly getClient: () => _aws_sdk_client_dynamodb.DynamoDBClient;
+        readonly tables: (mapping: Record<string, string>) => void;
+        readonly retry: (policy: RetryPolicy | null) => void;
+        readonly use: (mw: Middleware) => void;
+        readonly clearMiddleware: () => void;
     };
-}
-/**
- * Marker carried by a model's static `writes` member ({@link edgeWrites}), so it
- * can be recognized and read without depending on its declaration order. JSON is
- * never emitted from this object directly — it is the build-time declaration that
- * {@link deriveEdgeWriteItems} consumes.
- */
-declare const EDGE_WRITES_MARKER: unique symbol;
-/** The static `writes` declaration produced by {@link edgeWrites}. */
-interface EdgeWritesDefinition {
-    readonly [EDGE_WRITES_MARKER]: true;
-    /** The declared edge effects, in declaration order. */
-    readonly edges: readonly EdgeWriteDeclaration[];
-}
-/** Runtime guard: is `value` an {@link EdgeWritesDefinition}? */
-declare function isEdgeWritesDefinition(value: unknown): value is EdgeWritesDefinition;
-/**
- * The recorder handed to the {@link edgeWrites} builder. `putEdge` / `deleteEdge`
- * / `updateKeyChangeEdge` all declare the **same** edge (the adjacency row that
- * materializes a target relation); they read identically at the declaration site
- * to the three lifecycle effects the derivation emits, while keeping a single
- * declarative source of truth. Each returns an {@link EdgeWriteDeclaration};
- * collect them into the static `writes` member.
- */
-interface EdgeWriteRecorder {
-    /**
-     * Declare that creating this entity's row creates the edge read by
-     * `target`'s `relationProperty` relation (→ adjacency `Put`).
-     */
-    putEdge(target: () => new (...args: unknown[]) => unknown, relationProperty: string): EdgeWriteDeclaration;
-    /**
-     * Declare that deleting this entity's row deletes the edge read by
-     * `target`'s `relationProperty` relation (→ adjacency `Delete`).
-     */
-    deleteEdge(target: () => new (...args: unknown[]) => unknown, relationProperty: string): EdgeWriteDeclaration;
-    /**
-     * Declare that a foreign-key change moves the edge read by `target`'s
-     * `relationProperty` relation (→ adjacency `Delete`(old) + `Put`(new)).
-     */
-    updateKeyChangeEdge(target: () => new (...args: unknown[]) => unknown, relationProperty: string): EdgeWriteDeclaration;
-    /**
-     * Declare a **dual edge** (Epic #118 pattern 9 / issue #133): a bidirectional edge
-     * maintained as TWO physical rows — a forward row on THIS adjacency entity (read by
-     * `forward.target.relationProperty`) and an inverse row on a SECOND adjacency model
-     * (read by `inverse.target.relationProperty`). Both rows are written / deleted /
-     * moved together from this single declaration, so the two directions stay in sync
-     * without an inverse GSI. Use this when the reverse direction lives on its own
-     * partition (a second row) rather than a GSI of the forward row.
-     *
-     * @example
-     * ```ts
-     * // On the forward adjacency entity (FollowEdge: FOLLOWER#a / FOLLOWING#b):
-     * static readonly writes = edgeWrites((w) => [
-     *   w.dualEdge(
-     *     { target: () => UserModel, relationProperty: 'following' },
-     *     { adjacency: () => FollowedByEdgeModel, target: () => UserModel, relationProperty: 'followers' },
-     *   ),
-     * ]);
-     * ```
-     */
-    dualEdge(forward: {
-        target: () => new (...args: unknown[]) => unknown;
-        relationProperty: string;
-    }, inverse: {
-        adjacency: () => new (...args: unknown[]) => unknown;
-        target: () => new (...args: unknown[]) => unknown;
-        relationProperty: string;
-    }): EdgeWriteDeclaration;
-}
-/**
- * Declare an adjacency entity's edge write side (issue #82), as the model's
- * reusable save contract. The builder receives an {@link EdgeWriteRecorder} and
- * returns the declared edges; the result is stored on the model as
- * `static readonly writes = edgeWrites((w) => [...])`.
- *
- * The declaration is lifecycle-agnostic — `w.putEdge` / `w.deleteEdge` /
- * `w.updateKeyChangeEdge` all name the same edge; {@link deriveEdgeWriteItems}
- * derives the per-lifecycle item set. Using all three at the declaration site is
- * a readability convenience (the author writes `putEdge` under the create
- * contract, `deleteEdge` under the remove contract); they produce identical
- * declarations and the derivation is what distinguishes the lifecycle.
- *
- * @example
- * ```ts
- * // On the GroupMembership adjacency entity: its row is the User<->Group edge.
- * static readonly writes = edgeWrites((w) => [
- *   w.putEdge(() => GroupModel, 'members'),
- * ]);
- * ```
- */
-declare function edgeWrites(builder: (w: EdgeWriteRecorder) => readonly EdgeWriteDeclaration[]): EdgeWritesDefinition;
-/**
- * Derive the lifecycle-distinguished adjacency `Put` / `Delete`
- * {@link TransactionItemSpec} set for **one** declared edge.
- *
- * - `onCreate` → a single `Put` of the adjacency row (item = the edge key fields
- *   as `{field}` templates).
- * - `onDelete` → a single `Delete` keyed by the row's PK/SK.
- * - `onUpdateKeyChange` → a `Delete` of the **old** row (keyed in the
- *   `{old.<field>}` namespace) followed by a `Put` of the **new** row — the edge
- *   moves atomically. The two items are emitted in delete-then-put order so a key
- *   that is unchanged for one segment but changed for another never races the new
- *   row against the old delete within a transaction.
- *
- * The target relation is round-trip-verified ({@link assertRelationRoundTrips})
- * before any item is produced, so a mis-declared edge fails at build time rather
- * than writing an unreadable row.
- */
-declare function deriveEdgeWriteItemsFor(adjacencyClass: new (...args: unknown[]) => unknown, decl: EdgeWriteDeclaration, lifecycle: EdgeLifecycle): TransactionItemSpec[];
-/**
- * Derive the adjacency item set for **every** edge declared on an entity's
- * `writes` member, for one lifecycle phase, preserving declaration order. This is
- * the entry point a compiler (#85) calls to gather an entity's edge effects when
- * assembling a `TransactWriteItems`.
- *
- * @param adjacencyClass The adjacency model class whose row materializes the
- *                       edges (carries the `writes` declaration and the key).
- * @param writes         The entity's {@link EdgeWritesDefinition} (its static
- *                       `writes`).
- * @param lifecycle      Which lifecycle form to derive (`onCreate` / `onDelete` /
- *                       `onUpdateKeyChange`).
- */
-declare function deriveEdgeWriteItems(adjacencyClass: new (...args: unknown[]) => unknown, writes: EdgeWritesDefinition, lifecycle: EdgeLifecycle): TransactionItemSpec[];
-/**
- * Read the {@link EdgeWritesDefinition} declared on a model class as its static
- * `writes` member, or `undefined` when the model declares no edge write side.
- * Mirrors how {@link MetadataRegistry} discovers a model's static `keys` — it
- * scans the class's own static members for the marker — so the declaration needs
- * no fixed property name beyond the conventional `writes`.
- */
-declare function getEdgeWrites(modelClass: new (...args: unknown[]) => unknown): EdgeWritesDefinition | undefined;
-/**
- * Convenience over {@link deriveEdgeWriteItems} that reads the model's declared
- * `writes` member itself (via {@link getEdgeWrites}). Throws when the model
- * declares no edge write side, so a caller asking for edges of an undeclared
- * model gets an actionable error rather than an empty set.
- */
-declare function deriveModelEdgeWriteItems(modelClass: new (...args: unknown[]) => unknown, lifecycle: EdgeLifecycle): TransactionItemSpec[];
-
-/**
- * Maintenance **repair / rebuild planner** (Epic #118 Phase 2, issue #131).
- *
- * ## What this is
- *
- * The async drain ({@link import('../cdc/maintenance-drain.js')}, #130) keeps a
- * maintained owner row (a snapshot / collection / counter) in sync INCREMENTALLY —
- * it applies one source event at a time. Over a long-lived table the materialized
- * value can nevertheless **drift** from the source of truth: a dropped / dead-lettered
- * stream event, a maintainer added AFTER source rows already existed (initial
- * un-built state), a bug in an earlier maintainer version, or an out-of-band write.
- *
- * The rebuild planner is the repair for that drift. For a given owner row × maintainer
- * it **re-derives the owner-row value from scratch by scanning every source row that
- * belongs to that owner**, using the SAME projection / aggregation / ordering rules the
- * drain uses (shared via `maintenance-projection.ts` and this module), then:
- *
- *  - **{@link detectDrift}** — compares the re-derived value against the value currently
- *    stored on the owner row and reports whether (and how) they differ; or
- *  - **{@link rebuild}** — writes the re-derived ABSOLUTE value onto the owner row, so the
- *    materialized data converges to exactly what the source says.
- *
- * After a rebuild the owner row equals what an incremental drain would have converged to
- * had it never missed an event — the AC: "rebuild で materialized が source と一致する".
- *
- * ## Granularity: per owner row × maintainer
- *
- * Drift is detected and repaired at the **owner-row × maintainer** grain — the natural
- * unit, because one owner row's materialized value is a pure function of the set of
- * source rows bound to it. The caller names the owner rows to repair (their key inputs);
- * the planner discovers the source rows for each by querying the source on the maintenance
- * key binding (the same binding the live `hasMany` / `@aggregate` read uses, inverted:
- * the owner row supplies the binding value, the source partition is scanned for matches).
- *
- * ## count is re-derived as an ABSOLUTE SET, not an ADD
- *
- * The maintained counter applies a signed `ADD` per event (#141 / #130). A rebuild
- * instead **counts the source rows and SETs the absolute value** — it does not trust the
- * accumulated counter, it recomputes it. This is the whole point of repair (an ADD that
- * has drifted cannot be corrected by another ADD). The `max(field)` counter is re-derived
- * as the maximum over the scanned source rows and SET unconditionally (the rebuild is the
- * authority, so it does not use the drain's advance-only conditional guard).
- *
- * ## Execution form (production positioning)
- *
- * Like the drain applier, this is a **TS-side planner/executor** intended for dev/test and
- * **operational repair tooling** — run on-demand (a "repair this thread's summary now"
- * admin action) or as a periodic batch (a scheduled reconciliation sweep over a set of
- * owner rows). It is NOT injected into the SSoT spec and emits no generated artifact: a
- * rebuild is a host-side reconciliation against live DynamoDB, not part of a model's
- * compiled write contract — so there is no Python mirror (the Python runtime executes the
- * generated contract; rebuild is not in it). It reuses the maintenance graph (#124) to
- * resolve which maintainers exist and the shared re-derivation rules so a rebuilt value is
- * byte-consistent with a drained one.
- */
-
-/** A model class (or `ModelStatic`) the rebuild planner operates over. */
-type ModelLike = Function | ModelStatic<DDBModel>;
-/** Options for {@link createMaintenanceRebuilder}. */
-interface MaintenanceRebuildOptions {
-    /**
-     * The model classes whose maintainers this rebuilder can repair. The rebuilder
-     * builds a scoped {@link MaintenanceGraph} over them to resolve each
-     * owner-row × maintainer back to its declared effect. Defaults to the GLOBAL
-     * registry when omitted.
-     */
-    readonly models?: readonly ModelLike[];
-    /**
-     * The {@link ViewDefinition}s (`defineView`) whose maintainers this rebuilder can
-     * repair (issue #132). The view model classes are added to the scoped registry so a
-     * view row can be re-derived from its source rows, exactly like a relation owner row.
-     */
-    readonly views?: readonly ViewDefinition[];
-}
-/**
- * The drift verdict for one owner row × maintainer: whether the currently-stored
- * materialized value differs from the value re-derived from the source rows, and both
- * values (for diagnostics / a repair preview). `expected` is the re-derived authority;
- * `actual` is what the owner row currently holds (`undefined` when never built).
- */
-interface DriftReport {
-    /** The relation / aggregate property the maintained value lives under. */
-    readonly relationProperty: string;
-    /** The owner entity (logical name) the row belongs to. */
-    readonly ownerEntity: string;
-    /** The owner row's resolved key (`{ PK, SK }`). */
-    readonly ownerKey: Record<string, unknown>;
-    /** The maintained attribute (collection field / snapshot attrs / counter attribute). */
-    readonly kind: MaintainEffect['kind'];
-    /** True when `actual` differs from `expected` (drift present). */
-    readonly drifted: boolean;
-    /** The value re-derived from the source rows (the authority). */
-    readonly expected: unknown;
-    /** The value currently stored on the owner row (`undefined` when unbuilt). */
-    readonly actual: unknown;
-}
-/** The outcome of a {@link MaintenanceRebuilder.rebuild} over one owner row × maintainer. */
-interface RebuildResult extends DriftReport {
-    /** True when the owner row was written (drift was present and repaired). */
-    readonly repaired: boolean;
-}
-/**
- * A maintenance **repair / rebuild planner** (#131). Construct via
- * {@link createMaintenanceRebuilder}, then call {@link detectDrift} to compare or
- * {@link rebuild} to repair one owner row × maintainer (resolved by the owner model +
- * the relation/aggregate property + the owner key inputs).
- */
-declare class MaintenanceRebuilder {
-    private readonly graph;
-    constructor(opts?: MaintenanceRebuildOptions);
-    /**
-     * Re-derive the materialized value for one owner row × maintainer from the source
-     * rows and report whether it differs from what the owner row currently stores. Does
-     * NOT write anything (a read-only drift probe).
-     *
-     * @param owner The owner model class declaring the maintainer.
-     * @param relationProperty The relation / `@aggregate` property the value lives under.
-     * @param ownerKeyInput The owner row's key input (e.g. `{ threadId: 't1' }`).
-     */
-    detectDrift(owner: ModelLike, relationProperty: string, ownerKeyInput: Record<string, unknown>): Promise<DriftReport>;
-    /**
-     * Re-derive the materialized value for one owner row × maintainer from the source
-     * rows and WRITE the absolute re-derived value onto the owner row when it drifts (or
-     * always, when `force`). Returns the drift verdict plus whether a repair write ran.
-     *
-     * @param options.force Write even when no drift is detected (default: write only on drift).
-     */
-    rebuild(owner: ModelLike, relationProperty: string, ownerKeyInput: Record<string, unknown>, options?: {
-        force?: boolean;
-    }): Promise<RebuildResult>;
-    /** Resolve an owner model + property to its {@link MaintainItem} + owner-key builder. */
-    private resolve;
-    /**
-     * Scan every source row bound to this owner row and re-derive the maintained value:
-     *
-     *  - **collection** — project each source row, order + trim by the SAME read-side
-     *    rules (`orderBy` / `orderDir` / `maxItems`) the drain uses, return the list;
-     *  - **snapshot** — project the single bound source row (or `undefined` when none);
-     *  - **counter `count`** — the COUNT of source rows (absolute, not an ADD);
-     *  - **counter `max`** — the maximum source value of the tracked field.
-     */
-    private recompute;
-    /**
-     * The source rows bound to one owner row. The maintenance key binding is
-     * `{ ownerField: '$.entity.<sourceField>' }` (the destination owner-key field ← the
-     * source row's field). INVERTED for a rebuild: the owner row supplies the value, and
-     * the source partition is queried for rows whose `<sourceField>` matches — exactly the
-     * set the live `hasMany` / `@aggregate` read aggregates. Queries the source via the
-     * same {@link plan} the read planner uses (a partition Query), paginating fully.
-     */
-    private scanSourceRows;
-    /** Re-derive a bounded collection: project, then order + trim by the read-side rules. */
-    private recomputeCollection;
-    /**
-     * Re-derive a single-row snapshot. A snapshot mirrors ONE source row (a `belongsTo` /
-     * `hasOne`, normally 1:1). In the unusual case where MORE THAN ONE source row binds, the
-     * live single-value read takes the FIRST row in the source's natural query order
-     * (`ScanIndexForward`, default ASC = the smallest sort-key leaf), so re-derive the same
-     * row — {@link pickFirst} — for a verdict consistent with the live read. Returns
-     * `undefined` when no source row is bound (the snapshot should be absent).
-     */
-    private recomputeSnapshot;
-    /** The source entity metadata a maintain effect projects from (its relation target). */
-    private sourceMetaOf;
-    /** Re-derive a counter: the absolute COUNT of source rows, or the MAX of the tracked field. */
-    private recomputeCounter;
-    /** Read the owner row (consistent) for the drift comparison / actual value. */
-    private readOwnerRow;
-    /** The value currently stored on the owner row for this maintainer. */
-    private actualValue;
-    /** Write the re-derived ABSOLUTE value onto the owner row (the repair). */
-    private writeValue;
-}
-/** Create a {@link MaintenanceRebuilder} (issue #131). */
-declare function createMaintenanceRebuilder(opts?: MaintenanceRebuildOptions): MaintenanceRebuilder;
-
-/**
- * Type-level machinery for the parameterized definition DSL (issue #41).
- *
- * Two jobs:
- *
- * 1. {@link Parameterize} — relaxes a real key / changes / item input type so
- *    each scalar leaf additionally accepts a {@link Param} placeholder of the
- *    matching value type, while **field names and value types stay checked**
- *    against the underlying model (so the existing key boundary / `EntityInput`
- *    typing keeps biting at definition time).
- *
- * 2. {@link CollectParams} — derives the `name → ParamDescriptor` map from a
- *    supplied parameterized structure, preserving each placeholder's value type
- *    (`string` / `number` / literal union) in the descriptor.
- */
-
-/** Scalar leaf types that may be replaced by a {@link Param} placeholder. */
-type Replaceable = string | number;
-/** `null` / `undefined` — peeled off an optional leaf before the scalar test. */
-type Nullish = null | undefined;
-/**
- * Relaxes an input type `K` so each scalar leaf additionally accepts a
- * {@link Param} standing in for that leaf's value type. Non-scalar leaves and
- * field names are left exactly as declared, so excess-property / wrong-type /
- * wrong-name errors from the underlying key (or `EntityInput`) type still fire.
- *
- * A leaf of type `V` becomes `V | Param<V>`; a `string` literal field that is a
- * fixed discriminator (no param) is still assignable as its literal.
- *
- * The scalar test is written with a **tuple wrap** (`[…] extends […]`) so it does
- * **not** distribute over a literal-union leaf. A field typed `'a' | 'b'`
- * therefore yields the whole-union placeholder `Param<'a' | 'b'>` (what
- * `param.literal('a','b')` produces) rather than the distributed
- * `Param<'a'> | Param<'b'>`, which rejected the multi-value literal param (#246).
- * Because `Param` is covariant in its value type, a single-member placeholder
- * (`param.literal('a')` → `Param<'a'>`) still fits, while a placeholder carrying a
- * value **outside** the union (`Param<'a' | 'x'>`), a wider-typed placeholder
- * (`Param<string>` / `Param<number>` on a literal field), or a plain literal not
- * in the union stays a type error.
- *
- * `null` / `undefined` are peeled off first (via `Exclude`/`Extract`) and carried
- * through verbatim, so an **optional** leaf (`Partial<EntityInput>` in
- * `defineUpdate` changes) keeps accepting its placeholder — the tuple wrap alone
- * would otherwise send `string | undefined` down the object arm and drop the
- * placeholder.
- */
-type Parameterize<K> = [Exclude<K, Nullish>] extends [Replaceable] ? [Exclude<K, Nullish>] extends [never] ? K : Exclude<K, Nullish> | Param<Exclude<K, Nullish>> | Extract<K, Nullish> : K extends object ? {
-    [P in keyof K]: Parameterize<K[P]>;
-} : K;
-/**
- * Call-site excess-property guard for a parameterized structure (the key /
- * item / changes passed to a `define*` entry point).
- *
- * The entry points infer the structure as a bare `const` type parameter
- * (`const K extends Parameterize<Real>`). For a bare type parameter TypeScript
- * checks the constraint **structurally only** — there is no object-literal
- * *freshness* (excess-property) check, and `Real` (key inputs / `EntityInput`)
- * has all-optional-style members in several positions, so a stray key like
- * `bogus` slips through. This mirrors the exact hole `StrictSelect` (#37) closes
- * for `select`.
- *
- * {@link ExactParam} maps every key of the inferred `K` that is **not** a known
- * key of the (possibly union) `Real` input to `never`. Applied as
- * `key: K & ExactParam<Real, K>`, a stray key forces that property's type to
- * `never`, which the supplied value is not assignable to — a compile error.
- * Known keys keep their inferred value type, so {@link CollectParams} inference
- * is unaffected. Recurses into nested objects (embedded inputs).
- *
- * @typeParam Real - The underlying (non-parameterized) input type.
- * @typeParam K    - The inferred parameterized structure (per call).
- */
-type ExactParam<Real, K> = Real extends object ? {
-    [P in keyof K]: P extends KnownKeyOf<Real> ? K[P] extends Param<unknown> ? K[P] : K[P] extends object ? K[P] & ExactParam<NonNullableMember<Real, P>, K[P]> : K[P] : never;
-} : K;
-/** Union of all keys across every member of a (possibly union) `Real` type. */
-type KnownKeyOf<Real> = Real extends object ? keyof Real : never;
-/**
- * The value type of key `P` across the members of a (possibly union) `Real`,
- * with `null` / `undefined` stripped so the recursion targets the object shape.
- */
-type NonNullableMember<Real, P extends PropertyKey> = NonNullable<Real extends object ? (P extends keyof Real ? Real[P] : never) : never>;
-/**
- * Extracts the value type a {@link Param} represents, or `never` for non-params.
- */
-type ParamValueOf<X> = X extends Param<infer V> ? V : never;
-/**
- * Builds the `ParamDescriptor` (value type preserved) for a {@link Param}.
- * Mirrors the runtime descriptor shape produced by `collectParams`.
- */
-type DescriptorOf<V> = ParamDescriptor<V>;
-/**
- * Walks a supplied parameterized structure `K` and collects every
- * {@link Param} placeholder into a flat `name → ParamDescriptor` map. The
- * **object key** that holds a placeholder becomes the parameter name; the
- * placeholder's value type is preserved in the descriptor.
- *
- * Nested objects are flattened (a placeholder at any depth contributes its
- * immediate holding key). Concrete scalar leaves contribute nothing.
- */
-type CollectParams<K> = K extends object ? {
-    [P in keyof K as [ParamLeavesOf<K[P]>] extends [never] ? never : P]: K[P] extends Param<unknown> ? DescriptorOf<ParamValueOf<K[P]>> : DescriptorOf<ParamLeavesOf<K[P]>>;
-} extends infer M ? {
-    -readonly [P in keyof M]-?: M[P];
-} : never : Record<never, ParamDescriptor>;
-/**
- * Union of the value types of every {@link Param} reachable in `X` (itself or
- * nested). `never` when `X` contains no placeholders.
- */
-type ParamLeavesOf<X> = X extends Param<infer V> ? V : X extends object ? {
-    [P in keyof X]: ParamLeavesOf<X[P]>;
-}[keyof X] : never;
-
-/**
- * Parameterized query / command definition DSL (issue #41, Python-bridge
- * Phase 0a).
- *
- * ## API shape (deviation from the proposal, by design)
- *
- * The proposal sketches `User.query({ email: param.string() }, {...})`. That
- * record cannot be adopted without **polluting the live `Model.query` runtime
- * type** to accept {@link Param} placeholders at key/value positions — exactly
- * what issue #41 forbids ("must not pollute the runtime `Model.query` type with params"). So
- * this module provides **dedicated definition entry points** instead:
- *
- * - `defineQuery(Model, key, select)`
- * - `defineList(Model, key, select)`
- * - `definePut(Model, item)`
- * - `defineUpdate(Model, key, changes)`
- * - `defineDelete(Model, key)`
- *
- * These accept {@link Param} placeholders at scalar leaves while keeping field
- * names / value types / the key boundary / strict-select checked at definition
- * time (via {@link Parameterize} layered on the model's real key & select
- * types). `Model.query` / `Model.putItem` / … are **untouched**.
- *
- * `defineQueries({...})` / `defineCommands({...})` take a record of these
- * definition nodes and return the same record (typed), forming the IR the
- * static planner (#42) consumes.
- */
-
-/**
- * The model-class constructor type carried by a `ModelStatic<T, C>`. Mirrors the
- * pattern used by `model/types.ts` to recover precise key inference from the
- * model passed to a `define*` entry point.
- */
-type AnyModelClass = abstract new (...args: any[]) => DDBModel;
-/** Recovers the constructor type `C` from a `ModelStatic<T, C>` argument. */
-type ClassOf<M> = M extends ModelStatic<infer _T, infer C> ? C : unknown;
-/** Recovers the entity type `T` from a `ModelStatic<T, C>` argument. */
-type EntityOf<M> = M extends ModelStatic<infer T, infer _C> ? T : never;
-/**
- * Define a parameterized **single-item read** (`query`). The `key` accepts
- * {@link Param} placeholders at scalar leaves, but is otherwise checked against
- * the model's unique-key boundary (`UniqueQueryKeyOf`); `select` is the strict
- * projection (#37) typed against the entity.
- */
-declare function defineQuery<M extends ModelStatic<DDBModel, AnyModelClass>, const K extends Parameterize<UniqueQueryKeyOf<ClassOf<M>>>, const S extends SelectableOf<EntityOf<M>>>(model: M, key: K & ExactParam<UniqueQueryKeyOf<ClassOf<M>>, K>, select: S & StrictSelectSpec<EntityOf<M>, S>, options?: ReadDefinitionOptions): OperationDefinition<EntityOf<M>, 'query', K, S, undefined, CollectParams<K>>;
-/**
- * Define a parameterized **partition read** (`list`). The `key` accepts a
- * partial (partition-key) input with {@link Param} placeholders; `select` is
- * the strict projection typed against the entity.
- */
-declare function defineList<M extends ModelStatic<DDBModel, AnyModelClass>, const K extends Parameterize<PartialQueryKeyOf<ClassOf<M>>>, const S extends SelectableOf<EntityOf<M>>>(model: M, key: K & ExactParam<PartialQueryKeyOf<ClassOf<M>>, K>, select: S & StrictSelectSpec<EntityOf<M>, S>, options?: ReadDefinitionOptions): OperationDefinition<EntityOf<M>, 'list', K, S, undefined, CollectParams<K>>;
-/**
- * Define a parameterized **put** (`put`). The `item` accepts {@link Param}
- * placeholders at scalar leaves and is otherwise checked against `EntityInput`
- * (relations excluded, scalar/embedded field types enforced).
- */
-declare function definePut<M extends ModelStatic<DDBModel, AnyModelClass>, const I extends Parameterize<EntityInput<EntityOf<M>>>>(model: M, item: I & ExactParam<EntityInput<EntityOf<M>>, I>, options?: WriteDefinitionOptions): OperationDefinition<EntityOf<M>, 'put', I, undefined, undefined, CollectParams<I>>;
-/**
- * Define a parameterized **update** (`update`). Both `key` (PK) and `changes`
- * (a partial of the entity) accept {@link Param} placeholders at scalar leaves;
- * field names / value types are checked against the entity. Params from both
- * structures are merged into the definition's `params` map.
- */
-declare function defineUpdate<M extends ModelStatic<DDBModel, AnyModelClass>, const K extends Parameterize<PrimaryKeyOf<ClassOf<M>>>, const Ch extends Parameterize<Partial<EntityInput<EntityOf<M>>>>>(model: M, key: K & ExactParam<PrimaryKeyOf<ClassOf<M>>, K>, changes: Ch & ExactParam<Partial<EntityInput<EntityOf<M>>>, Ch>, options?: WriteDefinitionOptions): OperationDefinition<EntityOf<M>, 'update', K, undefined, Ch, CollectParams<K & Ch>>;
-/**
- * Define a parameterized **delete** (`delete`). The `key` (PK) accepts
- * {@link Param} placeholders at scalar leaves and is otherwise checked against
- * the model's primary-key type.
- */
-declare function defineDelete<M extends ModelStatic<DDBModel, AnyModelClass>, const K extends Parameterize<PrimaryKeyOf<ClassOf<M>>>>(model: M, key: K & ExactParam<PrimaryKeyOf<ClassOf<M>>, K>, options?: WriteDefinitionOptions): OperationDefinition<EntityOf<M>, 'delete', K, undefined, undefined, CollectParams<K>>;
-/**
- * Group a record of **read** definitions (`defineQuery` / `defineList`) into the
- * query IR consumed by the static planner (#42). The argument is validated to
- * contain only read operations; the returned map preserves each definition's
- * precise type (params, entity, select).
- */
-declare function defineQueries<const D extends DefinitionMap>(definitions: D & ReadOnlyDefinitions<D>): D;
-/**
- * Group a record of **write** definitions (`definePut` / `defineUpdate` /
- * `defineDelete`) into the command IR consumed by the static planner (#42). The
- * argument is validated to contain only write operations.
- */
-declare function defineCommands<const D extends DefinitionMap>(definitions: D & WriteOnlyDefinitions<D>): D;
-/** Constrains every entry of `D` to be a read (`query` / `list`) definition. */
-type ReadOnlyDefinitions<D extends DefinitionMap> = {
-    [K in keyof D]: D[K] extends OperationDefinition<infer _T, infer Op, infer _K, infer _S, infer _Ch, infer _P> ? Op extends 'query' | 'list' ? D[K] : OperationDefinition<DDBModel, 'query' | 'list', unknown, unknown, unknown, Record<string, ParamDescriptor>> : never;
-};
-/** Constrains every entry of `D` to be a write (`put`/`update`/`delete`) definition. */
-type WriteOnlyDefinitions<D extends DefinitionMap> = {
-    [K in keyof D]: D[K] extends OperationDefinition<infer _T, infer Op, infer _K, infer _S, infer _Ch, infer _P> ? Op extends 'put' | 'update' | 'delete' ? D[K] : OperationDefinition<DDBModel, 'put' | 'update' | 'delete', unknown, unknown, unknown, Record<string, ParamDescriptor>> : never;
 };
 
-export { AggregateOptions, AggregateValue, AotPreparedWriteStatement, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, ClientManager, type CollectParams, type ConditionExpressionResult, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, ParallelOpResult, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PreparedBody, PreparedPlanDocument, PreparedStatement, PreparedWriteExecOptions, PreparedWriteOpSpec, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, type QueryOptions$1 as QueryOptions, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, type RefsOptions, RelationMetadata, RelationOptions, type RelationTraversalOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, TransactionItemSpec, TransactionSpec, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, belongsTo, binary, boolean, buildConditionExpression, buildProjection, buildUpdateExpression, cdcProjected, compileFilterExpression, count, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, list, literal, loadPreparedPlan, maintainedFrom, map, max, model, number, numberSet, plan, refs, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, whenMember };
+export { DDBModel, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, type ListOptions, type MaintainedFromCallback, type MaintainedFromOptions, Middleware, type ModelOptions, PrimaryKeyOf, type ProjectionValue, type QueryOptions, type RefsOptions, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, type VersionedHistoryOptions, type VersionedLatestOptions, aggregate, belongsTo, binary, boolean, cdcProjected, count, datetime, embedded, field, graphddb, hasMany, hasOne, list, literal, maintainedFrom, map, max, model, number, numberSet, refs, string, stringSet, ttl, whenMember };