graphddb 0.5.0 → 0.5.2

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   buildBridgeBundle,
-  buildManifest,
-  normalizeSelectSpec
-} from "./chunk-J5A665UW.js";
+  buildManifest
+} from "./chunk-H5TUW2WR.js";
 import {
-  MetadataRegistry
-} from "./chunk-FMJIWFIS.js";
+  MetadataRegistry,
+  normalizeSelectSpec
+} from "./chunk-W3GEJPPV.js";
+import "./chunk-MCKGQKYU.js";
 
 // src/cli.ts
 import { createRequire } from "module";
@@ -568,7 +569,7 @@ function createProgram(handlers2, version) {
 
 // src/cli/handlers.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { dirname } from "path";
+import { dirname, relative } from "path";
 import { pathToFileURL } from "url";
 import { isAbsolute, resolve } from "path";
 
@@ -659,6 +660,9 @@ function collectResultTypes(manifest, entity, select, typeName, out, seen) {
       } else {
         fields.push([field, `${itemTypeName} | None`]);
       }
+      if (relation.description !== void 0) {
+        fieldDescriptions[field] = relation.description;
+      }
       continue;
     }
     if (value === true) {
@@ -790,7 +794,15 @@ function methodParams(def) {
   }
   return out;
 }
-function collectRepositories(queries, commands) {
+function gsiDescriptionForQuery(name, entity, manifest, querySpecs) {
+  if (!manifest || !querySpecs) return void 0;
+  const spec = querySpecs[name];
+  const indexName = spec?.operations[0]?.indexName;
+  if (indexName === void 0) return void 0;
+  const gsi = manifest.entities[entity]?.gsis.find((g) => g.indexName === indexName);
+  return gsi?.description;
+}
+function collectRepositories(queries, commands, manifest, querySpecs) {
   const byEntity = /* @__PURE__ */ new Map();
   const ensure = (entity) => {
     const cls = `${entityBaseName(entity)}Repository`;
@@ -803,13 +815,14 @@ function collectRepositories(queries, commands) {
   };
   for (const name of Object.keys(queries).sort()) {
     const def = queries[name];
+    const description = def.description ?? gsiDescriptionForQuery(name, def.entity.name, manifest, querySpecs);
     ensure(def.entity.name).push({
       methodName: toSnakeCase(name),
       params: methodParams(def),
       returnType: `${queryResultTypeName(name)} | None`,
       kind: "query",
       operationId: name,
-      ...def.description !== void 0 ? { description: def.description } : {}
+      ...description !== void 0 ? { description } : {}
     });
   }
   for (const name of Object.keys(commands).sort()) {
@@ -914,8 +927,8 @@ function renderTransactionsClass(methods) {
     body.join("\n\n")
   ].join("\n");
 }
-function generateRepositories(queries, commands, transactions = {}) {
-  const classes = collectRepositories(queries, commands);
+function generateRepositories(queries, commands, transactions = {}, manifest, querySpecs) {
+  const classes = collectRepositories(queries, commands, manifest, querySpecs);
   const txMethods = collectTransactionMethods(transactions);
   const resultTypes = /* @__PURE__ */ new Set();
   for (const name of Object.keys(queries)) {
@@ -1416,6 +1429,40 @@ function emitCloudformation(manifest, options = {}) {
   return (options.format ?? "yaml") === "json" ? templateToJson(template) : templateToYaml(template);
 }
 
+// src/codegen/cdc-registry.ts
+var TS_HEADER = PY_HEADER.replace("# ", "// ");
+function cdcProjectedModelNames(registry = MetadataRegistry) {
+  const names = [];
+  for (const [cls, metadata] of registry.getAll()) {
+    if (metadata.cdcProjected) names.push(cls.name);
+  }
+  return names.sort();
+}
+function generateCdcRegistry(options = {}) {
+  const registry = options.registry ?? MetadataRegistry;
+  const modelsModule = options.modelsModule ?? "./models.js";
+  const names = cdcProjectedModelNames(registry);
+  const lines = [TS_HEADER, ""];
+  if (names.length === 0) {
+    lines.push(
+      "// (no @cdcProjected models \u2014 nothing to augment CdcModelRegistry with)",
+      "",
+      "export {};",
+      ""
+    );
+    return lines.join("\n");
+  }
+  for (const name of names) {
+    lines.push(`import type { ${name} } from '${modelsModule}';`);
+  }
+  lines.push("", "declare module 'graphddb' {", "  interface CdcModelRegistry {");
+  for (const name of names) {
+    lines.push(`    ${name}: ${name};`);
+  }
+  lines.push("  }", "}", "");
+  return lines.join("\n");
+}
+
 // src/codegen/index.ts
 var OUTPUT_FILES = [
   "manifest.json",
@@ -1437,11 +1484,243 @@ function renderBundle(queries = {}, commands = {}, registry = MetadataRegistry,
     "manifest.json": JSON.stringify(bundle.manifest, null, 2) + "\n",
     "operations.json": JSON.stringify(bundle.operations, null, 2) + "\n",
     "types.py": generateTypes(bundle.manifest, queries, txSpecs, options),
-    "repositories.py": generateRepositories(queries, commands, txSpecs),
+    "repositories.py": generateRepositories(
+      queries,
+      commands,
+      txSpecs,
+      bundle.manifest,
+      bundle.operations.queries
+    ),
     "__init__.py": generateInit(queries, commands, txSpecs)
   };
 }
 
+// src/codegen/jsdoc.ts
+async function loadTypescript() {
+  try {
+    const mod = await import("./typescript-ZUQEBJRV.js");
+    return mod.default ?? mod;
+  } catch {
+    return void 0;
+  }
+}
+var warnedTypescriptMissing = false;
+var TYPESCRIPT_MISSING_WARNING = "warning: JSDoc description extraction skipped \u2014 'typescript' is not installed. Install typescript to enable it, or use explicit `description` fields.\n";
+function docCommentFor(ts, node) {
+  const jsDoc = node.jsDoc;
+  if (!jsDoc || jsDoc.length === 0) return void 0;
+  const last = jsDoc[jsDoc.length - 1];
+  const comment = last.comment;
+  if (typeof comment === "string") {
+    const t = comment.trim();
+    return t === "" ? void 0 : t;
+  }
+  if (Array.isArray(comment)) {
+    const joined = ts.getTextOfJSDocComment(comment);
+    if (joined) {
+      const t = joined.trim();
+      return t === "" ? void 0 : t;
+    }
+  }
+  return void 0;
+}
+function hasModelDecorator(ts, node) {
+  const decorators = ts.getDecorators?.(node) ?? [];
+  for (const dec of decorators) {
+    const expr = dec.expression;
+    const callee = ts.isCallExpression(expr) ? expr.expression : expr;
+    if (ts.isIdentifier(callee) && callee.text === "model") return true;
+  }
+  return false;
+}
+function gsiIndexNameOf(ts, init) {
+  if (!init || !ts.isCallExpression(init)) return void 0;
+  const callee = init.expression;
+  if (!ts.isIdentifier(callee) || callee.text !== "gsi") return void 0;
+  const first = init.arguments[0];
+  if (first && ts.isStringLiteralLike(first)) return first.text;
+  return void 0;
+}
+function collectClassDoc(ts, node) {
+  const members = /* @__PURE__ */ new Map();
+  const gsis = /* @__PURE__ */ new Map();
+  for (const member of node.members) {
+    if (ts.isPropertyDeclaration(member) && member.name) {
+      const doc = docCommentFor(ts, member);
+      if (doc === void 0) continue;
+      const gsiName = gsiIndexNameOf(ts, member.initializer);
+      if (gsiName !== void 0) {
+        gsis.set(gsiName, doc);
+      } else if (ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)) {
+        members.set(member.name.text, doc);
+      }
+    }
+  }
+  return { own: docCommentFor(ts, node), members, gsis };
+}
+function collectDefinitionDocs(ts, obj, into, ambiguous) {
+  for (const prop of obj.properties) {
+    if (!ts.isPropertyAssignment(prop)) continue;
+    if (!ts.isIdentifier(prop.name) && !ts.isStringLiteralLike(prop.name)) continue;
+    const key = prop.name.text;
+    if (into.has(key) || ambiguous.has(key)) {
+      into.delete(key);
+      ambiguous.add(key);
+      continue;
+    }
+    const params = /* @__PURE__ */ new Map();
+    collectParamDocs(ts, prop.initializer, params);
+    into.set(key, { own: docCommentFor(ts, prop), params });
+  }
+}
+function collectParamDocs(ts, node, into) {
+  const visit = (n) => {
+    if (ts.isPropertyAssignment(n)) {
+      const isParamCall = ts.isCallExpression(n.initializer) && ts.isPropertyAccessExpression(n.initializer.expression) && ts.isIdentifier(n.initializer.expression.expression) && n.initializer.expression.expression.text === "param";
+      if (isParamCall && (ts.isIdentifier(n.name) || ts.isStringLiteralLike(n.name))) {
+        const doc = docCommentFor(ts, n);
+        if (doc !== void 0) into.set(n.name.text, doc);
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(node, visit);
+}
+function extract(ts, files) {
+  const program = ts.createProgram(files, {
+    // Parse-only, permissive options: we never emit and never type-check the
+    // world — we only walk the AST of the requested files. `allowJs` lets a `.js`
+    // definition module (pre-compiled input) be parsed too.
+    allowJs: true,
+    noResolve: true,
+    noLib: true,
+    skipLibCheck: true,
+    types: [],
+    // The definition modules use TC39 standard decorators (repo tsconfig has
+    // `experimentalDecorators: false`); parsing is decorator-flavour agnostic for
+    // AST purposes, but keep it aligned.
+    experimentalDecorators: false
+  });
+  const classes = /* @__PURE__ */ new Map();
+  const ambiguousClassNames = /* @__PURE__ */ new Set();
+  const definitions = /* @__PURE__ */ new Map();
+  const ambiguousDefinitionKeys = /* @__PURE__ */ new Set();
+  const fileSet = new Set(files.map((f) => normalize(f)));
+  for (const sf of program.getSourceFiles()) {
+    if (!fileSet.has(normalize(sf.fileName))) continue;
+    const visit = (node) => {
+      if (ts.isClassDeclaration(node) && node.name && hasModelDecorator(ts, node)) {
+        const name = node.name.text;
+        if (classes.has(name) || ambiguousClassNames.has(name)) {
+          classes.delete(name);
+          ambiguousClassNames.add(name);
+        } else {
+          classes.set(name, collectClassDoc(ts, node));
+        }
+      }
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        if (ts.isIdentifier(callee) && (callee.text === "defineQueries" || callee.text === "defineCommands")) {
+          const arg = node.arguments[0];
+          if (arg && ts.isObjectLiteralExpression(arg)) {
+            collectDefinitionDocs(ts, arg, definitions, ambiguousDefinitionKeys);
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sf);
+  }
+  return {
+    classes,
+    ambiguousClassNames,
+    definitions,
+    ambiguousDefinitionKeys
+  };
+}
+function normalize(p) {
+  return p.replace(/\\/g, "/");
+}
+function mergeIntoRegistry(extracted, registry) {
+  const countByName = /* @__PURE__ */ new Map();
+  for (const [cls] of registry.getAll()) {
+    countByName.set(cls.name, (countByName.get(cls.name) ?? 0) + 1);
+  }
+  for (const [cls, meta] of registry.getAll()) {
+    const name = cls.name;
+    if (extracted.ambiguousClassNames.has(name)) continue;
+    if ((countByName.get(name) ?? 0) !== 1) continue;
+    const classDoc = extracted.classes.get(name);
+    if (!classDoc) continue;
+    applyClassDoc(classDoc, meta);
+  }
+}
+function applyClassDoc(classDoc, meta) {
+  if (meta.description === void 0 && classDoc.own !== void 0) {
+    meta.description = classDoc.own;
+  }
+  for (const field of meta.fields) {
+    const doc = classDoc.members.get(field.propertyName);
+    if (doc === void 0) continue;
+    if (field.options?.description !== void 0) continue;
+    field.options = { ...field.options ?? {}, description: doc };
+  }
+  for (const rel of meta.relations) {
+    const doc = classDoc.members.get(rel.propertyName);
+    if (doc === void 0) continue;
+    if (rel.options?.description !== void 0) continue;
+    rel.options = { ...rel.options ?? {}, description: doc };
+  }
+  for (const gsi of meta.gsiDefinitions) {
+    const doc = classDoc.gsis.get(gsi.indexName);
+    if (doc === void 0) continue;
+    if (gsi.description !== void 0) continue;
+    gsi.description = doc;
+  }
+}
+function mergeIntoDefinitions(extracted, map) {
+  for (const [key, def] of Object.entries(map)) {
+    if (extracted.ambiguousDefinitionKeys.has(key)) continue;
+    const defDoc = extracted.definitions.get(key);
+    if (!defDoc) continue;
+    if (def.description === void 0 && defDoc.own !== void 0) {
+      def.description = defDoc.own;
+    }
+    for (const [paramName, descriptor] of Object.entries(def.params)) {
+      const doc = defDoc.params.get(paramName);
+      if (doc === void 0) continue;
+      if (descriptor.description !== void 0) continue;
+      descriptor.description = doc;
+    }
+  }
+}
+async function applyJsDocDescriptions(sources, queries, commands, registry = MetadataRegistry, opts = {}) {
+  const ts = await (opts.loadTs ?? loadTypescript)();
+  if (!ts) {
+    if (!warnedTypescriptMissing) {
+      warnedTypescriptMissing = true;
+      (opts.warn ?? ((m) => void process.stderr.write(m)))(
+        TYPESCRIPT_MISSING_WARNING
+      );
+    }
+    return false;
+  }
+  try {
+    const files = [
+      sources.entry,
+      ...sources.queries ? [sources.queries] : [],
+      ...sources.commands ? [sources.commands] : []
+    ].filter((f, i, a) => a.indexOf(f) === i);
+    const extracted = extract(ts, files);
+    mergeIntoRegistry(extracted, registry);
+    mergeIntoDefinitions(extracted, queries);
+    mergeIntoDefinitions(extracted, commands);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/cli/handlers.ts
 function fail(code, message, exitCode) {
   process.stderr.write(JSON.stringify({ code, message }) + "\n");
@@ -1518,6 +1797,16 @@ var handlers = {
         contextsPath ?? contractsPath ?? entry,
         "contexts"
       );
+      const abs = (p) => isAbsolute(p) ? p : resolve(process.cwd(), p);
+      await applyJsDocDescriptions(
+        {
+          entry: abs(entry),
+          queries: abs(queriesPath ?? entry),
+          commands: abs(commandsPath ?? entry)
+        },
+        queries,
+        commands
+      );
       const files = renderBundle(queries, commands, void 0, transactions, {
         dataclass: Boolean(dataclass),
         contracts: { contracts, contexts }
@@ -1528,11 +1817,24 @@ var handlers = {
       for (const name of OUTPUT_FILES) {
         writeFileSync(resolve(outDir, name), files[name], "utf8");
       }
+      const emittedFiles = [...OUTPUT_FILES];
+      if (cdcProjectedModelNames().length > 0) {
+        const entryAbs = isAbsolute(entry) ? entry : resolve(process.cwd(), entry);
+        let modelsModule = relative(outDir, entryAbs).replace(/\\/g, "/").replace(/\.[mc]?ts$/, "");
+        if (!modelsModule.startsWith(".")) modelsModule = `./${modelsModule}`;
+        const cdcRegistryFile = "cdc-registry.ts";
+        writeFileSync(
+          resolve(outDir, cdcRegistryFile),
+          generateCdcRegistry({ modelsModule }),
+          "utf8"
+        );
+        emittedFiles.push(cdcRegistryFile);
+      }
       process.stdout.write(
         JSON.stringify({
           status: "ok",
           outDir: out,
-          files: [...OUTPUT_FILES]
+          files: emittedFiles
         }) + "\n"
       );
     } catch (err) {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SelectableOf, g as PrimaryKeyOf, h as RequestContext, i as Middleware, j as ReadRequestKind, k as CtxModel, l as ReadParams, m as ReadRequestCtx, D as DynamoDBOperation, I as Item, E as Executor, n as RetryPolicy, o as ExecutionPlanSpec, p as EntityMetadata, K as KeyDefinition, G as GsiDefinition, q as ModelKind, F as FieldOptions, r as DynamoType, s as ProjectionTransform, t as MaintainEvent, u as MembershipPredicate, v as MaintainConsistency, w as MaintainUpdateMode, x as MembershipPredicateOp, y as RelationOptions, A as AggregateOptions, z as AggregateValue, H as SelectBuilderSpec, J as RawCondition, L as TransactionSpec, N as Manifest, O as RetryOverride, Q as ExecutionPlan, V as FieldMetadata, X as ResolvedKey, R as ReadExecOptions, a as ExecutorResult, B as BatchGetExecInput, P as PutInput, W as WriteExecOptions, b as WriteResult, U as UpdateInput, c as DeleteInput, d as BatchWriteExecItem, e as BatchExecOptions, T as TransactWriteExecItem, Y as CdcEmulatorOptions, Z as ChangeHandler, _ as Unsubscribe, $ as FaultSpec, a0 as ConcurrentRecomputeRef, C as ChangeEvent, a1 as EventLog, a2 as ReplayOptions, a3 as ShardId, a4 as ViewDefinition, a5 as RelationMetadata, a6 as TransactionItemSpec, a7 as MaintainEffect, M as ModelStatic, f as DDBModel, a8 as Param, a9 as ParamDescriptor, aa as DefinitionMap, ab as OperationDefinition, ac as WriteDefinitionOptions, ad as PartialQueryKeyOf, ae as StrictSelectSpec, af as ReadDefinitionOptions, ag as EntityInput, ah as UniqueQueryKeyOf, ai as EntityRef, aj as ConditionInput, ak as QueryModelContract, al as QueryMethodSpec, am as CommandModelContract, an as CommandMethodSpec, ao as ContractSpec, ap as QuerySpec, aq as CommandSpec, ar as ContextSpec, as as OperationsDocument, at as AnyOperationDefinition, au as BridgeBundle, av as ConditionSpec } from './types-B-F7jw9f.js';
-export { aw as AggregateMetadata, ax as BatchDeleteRequest, ay as BatchGetOptions, az as BatchGetRequest, aA as BatchGetResult, aB as BatchPutRequest, aC as BatchResult, aD as BatchWriteRequest, aE as CONTRACT_RANGE_FANOUT_CONCURRENCY, aF as CdcMode, aG as Change, aH as ChangeBatch, aI as ChangeEventName, aJ as ClockMode, aK as CollectionEffect, aL as CollectionOptions, aM as Column, aN as ColumnMap, aO as CommandContractMethodSpec, aP as CommandInputShape, aQ as CommandMethod, aR as CommandPlan, aS as CommandResolutionTarget, aT as CommandResultKind, aU as CommandSelectShape, aV as CompiledFragment, aW as ComposeSpec, aX as CondSlot, aY as ConditionCheckInput, aZ as Connection, a_ as ContractCallSignature, a$ as ContractCardinality, b0 as ContractCommandParams, b1 as ContractCommandResult, b2 as ContractComposeNode, b3 as ContractFromRef, b4 as ContractInputArity, b5 as ContractItem, b6 as ContractKeyFieldRef, b7 as ContractKeyInput, b8 as ContractKeyRef, b9 as ContractKeySpec, ba as ContractKind, bb as ContractMethodOp, bc as ContractParamRef, bd as ContractQueryParams, be as ContractResolution, bf as CounterAggregate, bg as CounterEffect, bh as CtxBase, bi as DEFAULT_MAX_ATTEMPTS, bj as DEFAULT_RETRY_POLICY, bk as DeleteOptions, bl as DeriveEffect, bm as DerivedEdgeWrite, bn as DerivedUpdate, bo as DescriptorBinding, bp as ENTITY_WRITES_MARKER, bq as EdgeEffect, br as EffectPath, bs as EmbeddedMetadata, bt as EmitEffect, bu as EntityWritesDefinition, bv as EntityWritesShape, bw as ExecutableCommandContract, bx as ExecutableQueryContract, by as FilterInput, bz as FilterSpec, bA as FragmentInput, bB as GsiDefinitionMarker, bC as GsiOptions, bD as IdempotencyEffect, bE as InProcessWriteDescriptor, bF as InputArity, bG as KeyDefinitionMarker, bH as KeySegment, bI as KeySlot, bJ as KeyStructure, bK as KeyedResult, bL as LIFECYCLE_CONTRACT_MARKER, bM as LifecycleContract, bN as LifecycleEffects, bO as LiteralParam, bP as MaintainItem, bQ as MaintainTrigger, bR as MaintenanceGraph, bS as ManifestEntity, bT as ManifestField, bU as ManifestFieldType, bV as ManifestGsi, bW as ManifestKey, bX as ManifestRelation, bY as ManifestTable, bZ as MembershipEffect, b_ as ModelRef, b$ as MutateMode, c0 as MutateOptions, c1 as MutateParallelResult, c2 as MutateTransactionResult, c3 as MutationBody, c4 as MutationDescriptorMap, c5 as MutationFragment, c6 as MutationInputProxy, c7 as MutationInputRef, c8 as MutationIntent, c9 as NumberParam, ca as OperationKind, cb as OperationSpec, cc as ParallelOpResult, cd as ParamKind, ce as ParamSpec, cf as ParamStructure, cg as PersistCtx, ch as PersistOrigin, ci as PlannedCommandMethod, cj as ProjectionMap, ck as ProjectionTransformOp, cl as PutOptions, cm as QueryContractMethodSpec, cn as QueryEnvelopeResult, co as QueryKeyOf, cp as QueryMethod, cq as QueryResult, cr as RangeConditionSpec, cs as ReadEnvelope, ct as ReadOpCtx, cu as ReadOpKind, cv as ReadOperationType, cw as ReadRouteDescriptor, cx as ReadRouteOptions, cy as ReadRouteResult, cz as RecordedCompose, cA as RelationBuilder, cB as RelationConsistency, cC as RelationLimitOptions, cD as RelationPattern, cE as RelationProjection, cF as RelationReadOptions, cG as RelationSelect, cH as RelationSpec, cI as RelationUpdateMode, cJ as RelationWriteOptions, cK as RequiresEffect, cL as Resolution, cM as RetryInfo, cN as RetryOperationKind, cO as SPEC_VERSION, cP as SegmentSpec, cQ as SegmentedKey, cR as SelectBuilder, cS as SelectOf, cT as SnapshotEffect, cU as StartingPosition, cV as StreamViewType, cW as StringParam, cX as TransactionContext, cY as TransactionItemType, cZ as UniqueEffect, c_ as Updatable, c$ as UpdateOptions, d0 as ViewSourceSlice, d1 as WhenSpec, d2 as WriteCtx, d3 as WriteDescriptor, d4 as WriteEnvelope, d5 as WriteInput, d6 as WriteKind, d7 as WriteLifecyclePhase, d8 as WriteMiddleware, d9 as WriteOperationType, da as WriteRecorder, db as WriteResultProjection, dc as attachModelClass, dd as buildDeleteInput, de as buildMaintenanceGraph, df as buildPutInput, dg as buildUpdateInput, dh as collectViewDefinitions, di as compileFragment, dj as compileMutationPlan, dk as compileSingleFragmentPlan, dl as cond, dm as contractOfMethodSpec, dn as definePlan, dp as entityWrites, dq as executeBatchGet, dr as executeBatchWrite, ds as executeCommandMethod, dt as executeDelete, du as executeKeyedBatchGet, dv as executePut, dw as executeQueryMethod, dx as executeRangeFanout, dy as executeTransaction, dz as executeUpdate, dA as from, dB as getEntityWrites, dC as gsi, dD as identity, dE as isColumn, dF as isCommandModelContract, dG as isCommandPlan, dH as isContractComposeNode, dI as isContractFromRef, dJ as isContractKeyFieldRef, dK as isContractKeyRef, dL as isContractParamRef, dM as isEntityWritesDefinition, dN as isKeySegment, dO as isLifecycleContract, dP as isMaintainTrigger, dQ as isMutationFragment, dR as isMutationInputRef, dS as isParam, dT as isPlannedCommandMethod, dU as isQueryModelContract, dV as isRetryableError, dW as isRetryableTransactionCancellation, dX as k, dY as key, dZ as lifecyclePhaseForIntent, d_ as maintainTrigger, d$ as mintContractKeyFieldRef, e0 as mintContractParamRef, e1 as mutation, e2 as param, e3 as preview, e4 as publicCommandModel, e5 as publicQueryModel, e6 as query, e7 as resolveLifecycle, e8 as wholeKeysSentinel } from './types-B-F7jw9f.js';
+import { S as SelectableOf, g as PrimaryKeyOf, h as RequestContext, i as Middleware, j as ReadRequestKind, k as CtxModel, l as ReadParams, m as ReadRequestCtx, D as DynamoDBOperation, I as Item, E as Executor, n as RetryPolicy, o as ExecutionPlanSpec, p as EntityMetadata, K as KeyDefinition, G as GsiDefinition, q as ModelKind, F as FieldOptions, r as DynamoType, s as ProjectionTransform, t as MaintainEvent, u as MembershipPredicate, v as MaintainConsistency, w as MaintainUpdateMode, x as MembershipPredicateOp, y as RelationOptions, A as AggregateOptions, z as AggregateValue, H as SelectBuilderSpec, J as RawCondition, L as TransactionSpec, N as Manifest, O as RetryOverride, Q as ExecutionPlan, V as FieldMetadata, X as ResolvedKey, R as ReadExecOptions, a as ExecutorResult, B as BatchGetExecInput, P as PutInput, W as WriteExecOptions, b as WriteResult, U as UpdateInput, c as DeleteInput, d as BatchWriteExecItem, e as BatchExecOptions, T as TransactWriteExecItem, Y as CdcEmulatorOptions, Z as ChangeHandler, _ as Unsubscribe, $ as FaultSpec, a0 as ConcurrentRecomputeRef, C as ChangeEvent, a1 as EventLog, a2 as ReplayOptions, a3 as ShardId, a4 as ViewDefinition, a5 as RelationMetadata, a6 as TransactionItemSpec, a7 as MaintainEffect, M as ModelStatic, f as DDBModel, a8 as Param, a9 as ParamDescriptor, aa as DefinitionMap, ab as OperationDefinition, ac as WriteDefinitionOptions, ad as PartialQueryKeyOf, ae as StrictSelectSpec, af as ReadDefinitionOptions, ag as EntityInput, ah as UniqueQueryKeyOf, ai as EntityRef, aj as ConditionInput, ak as QueryModelContract, al as QueryMethodSpec, am as CommandModelContract, an as CommandMethodSpec, ao as ContractSpec, ap as QuerySpec, aq as CommandSpec, ar as ContextSpec, as as OperationsDocument, at as AnyOperationDefinition, au as BridgeBundle, av as ConditionSpec } from './types-m1Ect6hG.js';
+export { aw as AggregateMetadata, ax as BatchDeleteRequest, ay as BatchGetOptions, az as BatchGetRequest, aA as BatchGetResult, aB as BatchPutRequest, aC as BatchResult, aD as BatchWriteRequest, aE as CONTRACT_RANGE_FANOUT_CONCURRENCY, aF as CdcMode, aG as CdcModelRegistry, aH as CdcSubscribeHandlers, aI as Change, aJ as ChangeBatch, aK as ChangeEventName, aL as ClockMode, aM as CollectionEffect, aN as CollectionOptions, aO as Column, aP as ColumnMap, aQ as CommandContractMethodSpec, aR as CommandInputShape, aS as CommandMethod, aT as CommandPlan, aU as CommandResolutionTarget, aV as CommandResultKind, aW as CommandSelectShape, aX as CompiledFragment, aY as ComposeSpec, aZ as CondSlot, a_ as ConditionCheckInput, a$ as Connection, b0 as ContractCallSignature, b1 as ContractCardinality, b2 as ContractCommandParams, b3 as ContractCommandResult, b4 as ContractComposeNode, b5 as ContractFromRef, b6 as ContractInputArity, b7 as ContractItem, b8 as ContractKeyFieldRef, b9 as ContractKeyInput, ba as ContractKeyRef, bb as ContractKeySpec, bc as ContractKind, bd as ContractMethodOp, be as ContractParamRef, bf as ContractQueryParams, bg as ContractResolution, bh as CounterAggregate, bi as CounterEffect, bj as CtxBase, bk as DEFAULT_MAX_ATTEMPTS, bl as DEFAULT_RETRY_POLICY, bm as DeleteOptions, bn as DeriveEffect, bo as DerivedEdgeWrite, bp as DerivedUpdate, bq as DescriptorBinding, br as ENTITY_WRITES_MARKER, bs as EdgeEffect, bt as EffectPath, bu as EmbeddedMetadata, bv as EmitEffect, bw as EntityWritesDefinition, bx as EntityWritesShape, by as ExecutableCommandContract, bz as ExecutableQueryContract, bA as FilterInput, bB as FilterSpec, bC as FragmentInput, bD as GsiDefinitionMarker, bE as GsiOptions, bF as IdempotencyEffect, bG as InProcessWriteDescriptor, bH as InputArity, bI as KeyDefinitionMarker, bJ as KeySegment, bK as KeySlot, bL as KeyStructure, bM as KeyedResult, bN as LIFECYCLE_CONTRACT_MARKER, bO as LifecycleContract, bP as LifecycleEffects, bQ as LiteralParam, bR as MaintainItem, bS as MaintainTrigger, bT as MaintenanceGraph, bU as ManifestEntity, bV as ManifestField, bW as ManifestFieldType, bX as ManifestGsi, bY as ManifestKey, bZ as ManifestRelation, b_ as ManifestTable, b$ as MembershipEffect, c0 as ModelRef, c1 as MutateMode, c2 as MutateOptions, c3 as MutateParallelResult, c4 as MutateTransactionResult, c5 as MutationBody, c6 as MutationDescriptorMap, c7 as MutationFragment, c8 as MutationInputProxy, c9 as MutationInputRef, ca as MutationIntent, cb as NumberParam, cc as OperationKind, cd as OperationSpec, ce as ParallelOpResult, cf as ParamKind, cg as ParamSpec, ch as ParamStructure, ci as PersistCtx, cj as PersistOrigin, ck as PlannedCommandMethod, cl as ProjectionMap, cm as ProjectionTransformOp, cn as PutOptions, co as QueryContractMethodSpec, cp as QueryEnvelopeResult, cq as QueryKeyOf, cr as QueryMethod, cs as QueryResult, ct as RangeConditionSpec, cu as ReadEnvelope, cv as ReadOpCtx, cw as ReadOpKind, cx as ReadOperationType, cy as ReadRouteDescriptor, cz as ReadRouteOptions, cA as ReadRouteResult, cB as RecordedCompose, cC as RelationBuilder, cD as RelationConsistency, cE as RelationLimitOptions, cF as RelationPattern, cG as RelationProjection, cH as RelationReadOptions, cI as RelationSelect, cJ as RelationSpec, cK as RelationUpdateMode, cL as RelationWriteOptions, cM as RequiresEffect, cN as Resolution, cO as RetryInfo, cP as RetryOperationKind, cQ as SPEC_VERSION, cR as SegmentSpec, cS as SegmentedKey, cT as SelectBuilder, cU as SelectOf, cV as SnapshotEffect, cW as StartingPosition, cX as StreamViewType, cY as StringParam, cZ as SubscribeHandler, c_ as SubscribeHandlers, c$ as TransactionContext, d0 as TransactionItemType, d1 as UniqueEffect, d2 as Updatable, d3 as UpdateOptions, d4 as ViewSourceSlice, d5 as WhenSpec, d6 as WriteCtx, d7 as WriteDescriptor, d8 as WriteEnvelope, d9 as WriteInput, da as WriteKind, db as WriteLifecyclePhase, dc as WriteMiddleware, dd as WriteOperationType, de as WriteRecorder, df as WriteResultProjection, dg as attachModelClass, dh as buildDeleteInput, di as buildMaintenanceGraph, dj as buildPutInput, dk as buildSubscribeHandler, dl as buildUpdateInput, dm as collectViewDefinitions, dn as compileFragment, dp as compileMutationPlan, dq as compileSingleFragmentPlan, dr as cond, ds as contractOfMethodSpec, dt as definePlan, du as entityWrites, dv as executeBatchGet, dw as executeBatchWrite, dx as executeCommandMethod, dy as executeDelete, dz as executeKeyedBatchGet, dA as executePut, dB as executeQueryMethod, dC as executeRangeFanout, dD as executeTransaction, dE as executeUpdate, dF as from, dG as getEntityWrites, dH as gsi, dI as identity, dJ as isColumn, dK as isCommandModelContract, dL as isCommandPlan, dM as isContractComposeNode, dN as isContractFromRef, dO as isContractKeyFieldRef, dP as isContractKeyRef, dQ as isContractParamRef, dR as isEntityWritesDefinition, dS as isKeySegment, dT as isLifecycleContract, dU as isMaintainTrigger, dV as isMutationFragment, dW as isMutationInputRef, dX as isParam, dY as isPlannedCommandMethod, dZ as isQueryModelContract, d_ as isRetryableError, d$ as isRetryableTransactionCancellation, e0 as k, e1 as key, e2 as lifecyclePhaseForIntent, e3 as maintainTrigger, e4 as mintContractKeyFieldRef, e5 as mintContractParamRef, e6 as mutation, e7 as param, e8 as preview, e9 as publicCommandModel, ea as publicQueryModel, eb as query, ec as resolveLifecycle, ed as wholeKeysSentinel } from './types-m1Ect6hG.js';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 
@@ -735,6 +735,16 @@ interface MaintainedFromOptions<Self = unknown> {
     readonly when?: MembershipPredicate;
     readonly consistency?: MaintainConsistency;
     readonly updateMode?: MaintainUpdateMode;
+    /**
+     * Optional human-readable description of this maintained-from source slice (issue
+     * #166, follow-up of #154). Pure documentation metadata — it does NOT affect the
+     * maintenance IR or any runtime behaviour. Captured onto
+     * {@link MaintainedFromMetadata.description}. The maintenance IR is deliberately
+     * kept off `manifest.json` / `operations.json` and the generated Python (see the
+     * note on {@link MaintainedFromMetadata.description}), so this is a metadata-layer
+     * capture only. Omit for byte-identical metadata.
+     */
+    readonly description?: string;
 }
 /** The `(self, source) =>` symbolic callback evaluated at decoration time. */
 type MaintainedFromCallback<Self, Source> = (self: SelfProxy<Self>, source: SourceProxy<Source>) => MaintainedFromOptions<Self>;
@@ -837,7 +847,7 @@ type HasManyVersionedCallback<Self, Source> = (self: SelfProxy<Self>, source: So
 declare function hasMany(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function hasMany<Self = unknown, Source = unknown>(targetFactory: () => new (...args: unknown[]) => unknown, callback: HasManyVersionedCallback<Self, Source>): (value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function belongsTo(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (_value: undefined, context: ClassFieldDecoratorContext) => void;
-declare function hasOne(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>): (value: undefined, context: ClassFieldDecoratorContext) => void;
+declare function hasOne(targetFactory: () => new (...args: unknown[]) => unknown, keyBinding: Record<string, string>, options?: RelationOptions): (value: undefined, context: ClassFieldDecoratorContext) => void;
 declare function hasOne<Self = unknown, Source = unknown>(targetFactory: () => new (...args: unknown[]) => unknown, callback: HasOneVersionedCallback<Self, Source>): (value: undefined, context: ClassFieldDecoratorContext) => void;
 
 /**
@@ -923,6 +933,51 @@ declare function count(): AggregateValue;
  */
 declare function max(field: string): AggregateValue;
 
+/**
+ * `@cdcProjected()` — mark a source model **CDC-parseable** (issue #153).
+ *
+ * ## What it is
+ *
+ * External projection means projecting a source model's changes onto an external
+ * sink (BigQuery / OpenSearch / …) over CDC (DynamoDB Streams). graphddb owns only
+ * the **parse → typed record** contract; the sink write / dedup / delivery live in
+ * the consumer's CDC infrastructure, OUTSIDE the boundary (see
+ * `docs/cdc-projection.md`). `@cdcProjected()` is the model-level opt-in that
+ * enables that contract on a model:
+ *
+ * - `Model.fromChange(event)` (the pure `(event) => [old, new]` typed mapper) is
+ *   gated on it — calling it on an un-annotated model throws (and is a compile
+ *   error via the type surface);
+ * - `DDBModel.subscribe(handlers)` routes CDC events only to `@cdcProjected` models;
+ * - the codegen reads the flag to emit the `CdcModelRegistry` module augmentation
+ *   that types `subscribe`'s handlers by model name.
+ *
+ * ## No runtime side effect
+ *
+ * The decorator carries NO runtime — it does not subscribe, write, capture, or hook
+ * anything. It only flips a capability bit
+ * ({@link import('../metadata/types.js').EntityMetadata.cdcProjected}) on the model's
+ * metadata. Like `@maintainedFrom`, it is a CLASS-LEVEL decorator that runs BEFORE
+ * the topmost `@model` (TC39 bottom-up class-decorator ordering), so it pushes into
+ * the module-level collector and `@model` drains it. Stacking it above or below
+ * other class decorators carries no meaning.
+ *
+ * @example
+ * ```ts
+ * @model({ table: 'Orders', prefix: 'ORDER' })
+ * @cdcProjected()
+ * class OrderModel extends DDBModel {
+ *   static readonly keys = key<{ orderId: string }>((c) => ({
+ *     pk: k`ORDER#${c.orderId}`, sk: k`META`,
+ *   }));
+ *   @string orderId!: string;
+ *   @string status!: string;
+ *   @datetime updatedAt!: Date;
+ * }
+ * ```
+ */
+declare function cdcProjected(): (_target: Function, _context: ClassDecoratorContext) => void;
+
 declare class TableMapping {
     private static mapping;
     static set(mapping: Record<string, string>): void;
@@ -1571,6 +1626,46 @@ declare function createMaintenanceDrain(opts?: MaintenanceDrainOptions): Mainten
  */
 declare function createMaintenanceDrainHandler(opts?: MaintenanceDrainOptions): ChangeHandler;
 
+/**
+ * `fromChange` — the pure `(event) => [old, new]` typed mapper (issue #153).
+ *
+ * This is graphddb's HALF of the CDC-projection boundary (see
+ * `docs/cdc-projection.md`): it parses a raw {@link ChangeEvent}'s `oldImage` /
+ * `newImage` into typed model instances and does nothing downstream of that (no
+ * sink write, no dedup, no subscription). `Model.fromChange(event)` on `DDBModel`
+ * delegates here.
+ *
+ * The two responsibilities packed into one call are **routing** and **parse**:
+ *
+ * - Routing — an event that is not for `modelClass` yields `[null, null]`. A valid
+ *   event for the class always has at least one non-null image, so `[null, null]`
+ *   is an unambiguous "not for this model" signal and no separate `owns()` guard is
+ *   needed. The match is by `event.model` (the resolved model name the write path /
+ *   emulator stamps) when present, falling back to the model's PK prefix
+ *   (`keys.pk` begins with `<prefix>`) when the event carries no `model`.
+ * - Parse — each present image is hydrated via the existing {@link hydrate}
+ *   (raw item → typed value, INCLUDING ISO 8601 → `Date` for `@datetime` and
+ *   embedded reconstruction), returning ALL fields (no projection — narrowing does
+ *   not reduce network cost since the image is already on the stream). The hydrated
+ *   plain record is then loaded onto a fresh model instance so the result is a
+ *   genuine `InstanceType` (like the read path's `{ hydrate }` factory option).
+ *
+ * The image side present per event kind mirrors DynamoDB Streams:
+ *
+ * - INSERT → `[null,      new ]`
+ * - MODIFY → `[old,       new ]`
+ * - REMOVE → `[old,       null]`
+ */
+
+/**
+ * Parse a {@link ChangeEvent} into the `[oldRecord, newRecord]` tuple for the given
+ * model. Returns `[null, null]` when the event is not for this model (routing). The
+ * caller (`DDBModel.fromChange`) supplies the resolved metadata + class; this
+ * function is the runtime core and is deliberately model-name-string driven so
+ * `DDBModel.subscribe` can reuse it when routing a batch.
+ */
+declare function parseChange<T extends object>(event: ChangeEvent, metadata: EntityMetadata, modelName: string, modelClass: new () => T): [T | null, T | null];
+
 /**
  * Per-key cursor envelope for batched `range` (`list`) contract methods (issue
  * #62, CQRS single-service runtime; spec `docs/cqrs-contract.md`,
@@ -3065,4 +3160,4 @@ declare function assertBundleSerializable(bundle: BridgeBundle): void;
  */
 declare function buildBridgeBundle(queries?: DefinitionMap, commands?: DefinitionMap, registry?: typeof MetadataRegistry, transactions?: Record<string, TransactionDefinition>, contractInputs?: ContractInputs): BridgeBundle;
 
-export { AggregateOptions, AggregateValue, type AnyModelContract, AnyOperationDefinition, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, BridgeBundle, type BuiltContracts, CdcEmulator, CdcEmulatorOptions, ChangeEvent, ChangeHandler, ClientManager, type CollectParams, CommandMethodSpec, CommandModelContract, CommandSpec, ConcurrentRecomputeRef, type ConditionExpressionResult, ConditionInput, ConditionSpec, type ContextOwnership, type ContextOwnershipMap, ContextSpec, type ContractBoundaryViolation, type ContractInputs, type ContractMap, type ContractN1Violation, ContractSpec, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, EntityRef, EventLog, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FaultSpec, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type LintResult, type LintRule, Linter, type ListInput, type ListOptions, MAINT_OUTBOX_PK_PREFIX, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, MaintenanceDrain, type MaintenanceDrainOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, MetadataRegistry, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, OperationsDocument, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, QueryMethodSpec, QueryModelContract, type QueryOptions$1 as QueryOptions, QuerySpec, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, RelationMetadata, RelationOptions, type RelationTraversalOptions, ReplayOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, ShardId, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, type TransactionDefinition, TransactionItemSpec, type TransactionParamShape, type TransactionRef, TransactionSpec, type TxConditionCheckOptions, type TxForEachInstruction, type TxForEachOptions, type TxInstruction, type TxRecorder, type TxWriteInstruction, type TxWriteOptions, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, type WhenComparison, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, belongsTo, binary, boolean, buildBridgeBundle, buildConditionExpression, buildContexts, buildContracts, buildManifest, buildOperations, buildProjection, buildQuerySpec, buildTransactionSpec, buildTransactions, buildUpdateExpression, collectContractBoundaryViolations, collectContractN1Violations, compileFilterExpression, count, createCdcEmulator, createDefaultLinter, createMaintenanceDrain, createMaintenanceDrainHandler, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineTransaction, defineTransactions, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, gsiAmbiguityRule, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, isTransactionRef, list, literal, maintainedFrom, map, max, missingGsiRule, model, noScanRule, number, numberSet, plan, queryBoundaryRule, relationDepthRule, requireLimitRule, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, when, whenMember };
+export { AggregateOptions, AggregateValue, type AnyModelContract, AnyOperationDefinition, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, BridgeBundle, type BuiltContracts, CdcEmulator, CdcEmulatorOptions, ChangeEvent, ChangeHandler, ClientManager, type CollectParams, CommandMethodSpec, CommandModelContract, CommandSpec, ConcurrentRecomputeRef, type ConditionExpressionResult, ConditionInput, ConditionSpec, type ContextOwnership, type ContextOwnershipMap, ContextSpec, type ContractBoundaryViolation, type ContractInputs, type ContractMap, type ContractN1Violation, ContractSpec, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, EntityRef, EventLog, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FaultSpec, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type LintResult, type LintRule, Linter, type ListInput, type ListOptions, MAINT_OUTBOX_PK_PREFIX, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, MaintenanceDrain, type MaintenanceDrainOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, MetadataRegistry, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, OperationsDocument, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, QueryMethodSpec, QueryModelContract, type QueryOptions$1 as QueryOptions, QuerySpec, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, RelationMetadata, RelationOptions, type RelationTraversalOptions, ReplayOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, ShardId, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, type TransactionDefinition, TransactionItemSpec, type TransactionParamShape, type TransactionRef, TransactionSpec, type TxConditionCheckOptions, type TxForEachInstruction, type TxForEachOptions, type TxInstruction, type TxRecorder, type TxWriteInstruction, type TxWriteOptions, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, type WhenComparison, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, belongsTo, binary, boolean, buildBridgeBundle, buildConditionExpression, buildContexts, buildContracts, buildManifest, buildOperations, buildProjection, buildQuerySpec, buildTransactionSpec, buildTransactions, buildUpdateExpression, cdcProjected, collectContractBoundaryViolations, collectContractN1Violations, compileFilterExpression, count, createCdcEmulator, createDefaultLinter, createMaintenanceDrain, createMaintenanceDrainHandler, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineTransaction, defineTransactions, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, gsiAmbiguityRule, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, isTransactionRef, list, literal, maintainedFrom, map, max, missingGsiRule, model, noScanRule, number, numberSet, parseChange, plan, queryBoundaryRule, relationDepthRule, requireLimitRule, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, when, whenMember };