@farukada/aws-langgraph-dynamodb-ts 0.9.0 → 1.0.0-rc.2

package/dist/shared/validation/collaborators.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Hides what a collaborator a caller hands in must offer.
+ *
+ * An injected client, logger, serde, embeddings model or vector backend is
+ * checked by the members this package calls on it, and a cancellation signal
+ * — at construction or on a single call's options — by the members an
+ * `AbortSignal` has, so a wrong object fails where it was passed and not at the
+ * first call deep inside an operation.
+ */
+import type { CancelOptions } from '../options';
+/** The `DynamoDBDocument` methods this package calls on an injected `client`. */
+export declare const CLIENT_MEMBERS: readonly string[];
+/** The `Logger` methods every adapter calls. */
+export declare const LOGGER_MEMBERS: readonly string[];
+/** The `SerializerProtocol` methods this package calls on `serde`. */
+export declare const SERDE_MEMBERS: readonly string[];
+/** The `Embeddings` methods this package calls on `index.embeddings`. */
+export declare const EMBEDDINGS_MEMBERS: readonly string[];
+/**
+ * The `VectorBackend` methods this package calls. `listKeys` is deliberately
+ * excluded: it is optional on the interface (`store/vector-backend.ts`), and
+ * `reconcileVectorIndex` already branches on its absence and logs instead of
+ * requiring it — requiring it here would refuse a backend shape this package
+ * documents and supports.
+ */
+export declare const VECTOR_BACKEND_MEMBERS: readonly string[];
+/**
+ * Every `AbortSignal` member this package uses on a caller's `signal`, with
+ * the `typeof` each must have: `aborted` is read before a request and between
+ * pages, and the wait between retries attaches an abort listener and removes
+ * it again from inside its timer. `reason` is only read, which is safe on any
+ * object, so it is not required.
+ */
+export declare const ABORT_SIGNAL_MEMBERS: Readonly<Record<string, 'boolean' | 'function'>>;
+/**
+ * Refuse a collaborator missing a method this package calls.
+ *
+ * Checked by shape, never `instanceof`: the rule is banned repo-wide, and a
+ * duck-typed check also survives two copies of a dependency in one tree, which
+ * is exactly the situation an injected client comes from.
+ *
+ * Accepts: `value` — the collaborator as the caller gave it. `members` — every
+ * method this package calls on it. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field` for a non-object, `null` or an array,
+ * and `field.member` for the first missing method — naming which member is
+ * missing is what turns a first-request crash into a startup error a caller
+ * can act on. An array is refused as a whole rather than reported as missing
+ * its first method, which would point the caller at a method instead of at
+ * the value.
+ */
+export declare function assertMembers(value: object, members: readonly string[], field: string): void;
+/**
+ * Validate the collaborators every adapter shares: `client`, `logger` and
+ * `serde`. Pulled out of each `setUp*` as one call rather than three inline
+ * checks, so the three adapters check them the same way.
+ *
+ * Accepts: `options` — the adapter options, narrowed to the three shared
+ * collaborator fields. Every field here is typed as `object`, which a real
+ * `DynamoDBDocument`, `Logger` or `SerializerProtocol` all satisfy, so any
+ * adapter's options type is assignable without a cast.
+ *
+ * Returns: nothing: each collaborator given is kept under its declared type,
+ * and this checks it. A collaborator the caller did not supply is left
+ * untouched, so it still reaches its default.
+ *
+ * Throws: see {@link assertMembers}.
+ */
+export declare function assertBaseCollaborators(options: {
+    client?: object;
+    logger?: object;
+    serde?: object;
+}): void;
+/**
+ * A value usable as an `AbortSignal`, checked by shape.
+ *
+ * `signal` is not a method bag like the collaborators above, so this returns
+ * a boolean rather than throwing: it never needs to be paired with the
+ * caller's own decision about what an absent signal means.
+ *
+ * Accepts: `value` — the caller's `signal`, or `undefined`.
+ *
+ * Returns: `true` when `value` is a non-null object whose every member in
+ * {@link ABORT_SIGNAL_MEMBERS} has the type listed there — `false` otherwise,
+ * including for `undefined`.
+ *
+ * Throws: nothing.
+ */
+export declare function isAbortSignalLike(value: AbortSignal | undefined): boolean;
+/**
+ * Throw `VALIDATION` naming `field` unless `value` is absent or
+ * {@link isAbortSignalLike}.
+ *
+ * Accepts: `value` — a caller's signal, or `undefined`. `field` — what the
+ * error names; `signal` by default, and the full path for a signal nested in
+ * another option (`retry.signal`), so a caller whose top-level `signal` is
+ * valid is not pointed at it.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field`. Left unchecked, a value that is not
+ * an `AbortSignal` reaches whatever this package hands it to — an
+ * `addEventListener` call, a retry loop reading `.aborted`, a
+ * `removeEventListener` call from inside a timer, where nothing can catch it —
+ * and fails there with a raw, unrelated error instead of naming the option
+ * that caused it.
+ */
+export declare function assertSignalLike(value: AbortSignal | undefined, field?: string): void;
+/**
+ * The keys of a cancellation-only option bag, exhaustive in both directions.
+ *
+ * Every feature's own option-bag lists live in that feature's `internal/`
+ * directory, beside the types they are checked against;
+ * `shared/` knows no feature. This one stays here because `CancelOptions` is
+ * shared by all three. `allKeysOf<T>` keeps the list from drifting from the
+ * type it guards: an exhaustive list compiles, omitting or inventing a key
+ * does not.
+ */
+export declare const CANCEL_KEYS: readonly string[];
+/**
+ * Reject a `{ signal }` bag carrying a key this package does not read.
+ *
+ * Pulled out as one call because several methods across three classes take
+ * only cancellation (`addMessages`, `addMessage`, `clear`,
+ * `reconcileMessageCount`, `deleteThread`, `reconcileVectorIndex`) — one
+ * shared check keeps their wording and their key list from drifting apart.
+ *
+ * Accepts: `options` — as the caller passed it; absent is left alone, since
+ * there is nothing to check.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `options.<key>` for the first key this
+ * package does not read, or `signal` for a value that is not AbortSignal-like.
+ */
+export declare function assertCancelOptions(options: CancelOptions | undefined): void;

package/dist/shared/validation/collaborators.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Hides what a collaborator a caller hands in must offer.
+ *
+ * An injected client, logger, serde, embeddings model or vector backend is
+ * checked by the members this package calls on it, and a cancellation signal
+ * — at construction or on a single call's options — by the members an
+ * `AbortSignal` has, so a wrong object fails where it was passed and not at the
+ * first call deep inside an operation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANCEL_KEYS = exports.ABORT_SIGNAL_MEMBERS = exports.VECTOR_BACKEND_MEMBERS = exports.EMBEDDINGS_MEMBERS = exports.SERDE_MEMBERS = exports.LOGGER_MEMBERS = exports.CLIENT_MEMBERS = void 0;
+exports.assertMembers = assertMembers;
+exports.assertBaseCollaborators = assertBaseCollaborators;
+exports.isAbortSignalLike = isAbortSignalLike;
+exports.assertSignalLike = assertSignalLike;
+exports.assertCancelOptions = assertCancelOptions;
+const errors_1 = require("../errors/errors");
+const option_shape_1 = require("./option-shape");
+/** The `DynamoDBDocument` methods this package calls on an injected `client`. */
+exports.CLIENT_MEMBERS = [
+    'get',
+    'put',
+    'delete',
+    'update',
+    'query',
+    'scan',
+    'batchWrite',
+    'transactWrite',
+];
+/** The `Logger` methods every adapter calls. */
+exports.LOGGER_MEMBERS = ['debug', 'info', 'warn', 'error'];
+/** The `SerializerProtocol` methods this package calls on `serde`. */
+exports.SERDE_MEMBERS = ['dumpsTyped', 'loadsTyped'];
+/** The `Embeddings` methods this package calls on `index.embeddings`. */
+exports.EMBEDDINGS_MEMBERS = ['embedQuery', 'embedDocuments'];
+/**
+ * The `VectorBackend` methods this package calls. `listKeys` is deliberately
+ * excluded: it is optional on the interface (`store/vector-backend.ts`), and
+ * `reconcileVectorIndex` already branches on its absence and logs instead of
+ * requiring it — requiring it here would refuse a backend shape this package
+ * documents and supports.
+ */
+exports.VECTOR_BACKEND_MEMBERS = ['upsert', 'query', 'delete'];
+/**
+ * Every `AbortSignal` member this package uses on a caller's `signal`, with
+ * the `typeof` each must have: `aborted` is read before a request and between
+ * pages, and the wait between retries attaches an abort listener and removes
+ * it again from inside its timer. `reason` is only read, which is safe on any
+ * object, so it is not required.
+ */
+exports.ABORT_SIGNAL_MEMBERS = {
+    aborted: 'boolean',
+    addEventListener: 'function',
+    removeEventListener: 'function',
+};
+/**
+ * Refuse a collaborator missing a method this package calls.
+ *
+ * Checked by shape, never `instanceof`: the rule is banned repo-wide, and a
+ * duck-typed check also survives two copies of a dependency in one tree, which
+ * is exactly the situation an injected client comes from.
+ *
+ * Accepts: `value` — the collaborator as the caller gave it. `members` — every
+ * method this package calls on it. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field` for a non-object, `null` or an array,
+ * and `field.member` for the first missing method — naming which member is
+ * missing is what turns a first-request crash into a startup error a caller
+ * can act on. An array is refused as a whole rather than reported as missing
+ * its first method, which would point the caller at a method instead of at
+ * the value.
+ */
+function assertMembers(value, members, field) {
+    if (!(0, option_shape_1.isObjectShape)(value)) {
+        throw (0, errors_1.validationError)(`${field} must be an object`, field);
+    }
+    for (const member of members) {
+        if (typeof Reflect.get(value, member) !== 'function') {
+            throw (0, errors_1.validationError)(`${field}.${member} must be a function`, `${field}.${member}`);
+        }
+    }
+}
+/**
+ * Validate the collaborators every adapter shares: `client`, `logger` and
+ * `serde`. Pulled out of each `setUp*` as one call rather than three inline
+ * checks, so the three adapters check them the same way.
+ *
+ * Accepts: `options` — the adapter options, narrowed to the three shared
+ * collaborator fields. Every field here is typed as `object`, which a real
+ * `DynamoDBDocument`, `Logger` or `SerializerProtocol` all satisfy, so any
+ * adapter's options type is assignable without a cast.
+ *
+ * Returns: nothing: each collaborator given is kept under its declared type,
+ * and this checks it. A collaborator the caller did not supply is left
+ * untouched, so it still reaches its default.
+ *
+ * Throws: see {@link assertMembers}.
+ */
+function assertBaseCollaborators(options) {
+    if (options.client !== undefined)
+        assertMembers(options.client, exports.CLIENT_MEMBERS, 'client');
+    if (options.logger !== undefined)
+        assertMembers(options.logger, exports.LOGGER_MEMBERS, 'logger');
+    if (options.serde !== undefined)
+        assertMembers(options.serde, exports.SERDE_MEMBERS, 'serde');
+}
+/**
+ * A value usable as an `AbortSignal`, checked by shape.
+ *
+ * `signal` is not a method bag like the collaborators above, so this returns
+ * a boolean rather than throwing: it never needs to be paired with the
+ * caller's own decision about what an absent signal means.
+ *
+ * Accepts: `value` — the caller's `signal`, or `undefined`.
+ *
+ * Returns: `true` when `value` is a non-null object whose every member in
+ * {@link ABORT_SIGNAL_MEMBERS} has the type listed there — `false` otherwise,
+ * including for `undefined`.
+ *
+ * Throws: nothing.
+ */
+function isAbortSignalLike(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return Object.entries(exports.ABORT_SIGNAL_MEMBERS).every(([member, type]) => typeof Reflect.get(value, member) === type);
+}
+/**
+ * Throw `VALIDATION` naming `field` unless `value` is absent or
+ * {@link isAbortSignalLike}.
+ *
+ * Accepts: `value` — a caller's signal, or `undefined`. `field` — what the
+ * error names; `signal` by default, and the full path for a signal nested in
+ * another option (`retry.signal`), so a caller whose top-level `signal` is
+ * valid is not pointed at it.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field`. Left unchecked, a value that is not
+ * an `AbortSignal` reaches whatever this package hands it to — an
+ * `addEventListener` call, a retry loop reading `.aborted`, a
+ * `removeEventListener` call from inside a timer, where nothing can catch it —
+ * and fails there with a raw, unrelated error instead of naming the option
+ * that caused it.
+ */
+function assertSignalLike(value, field = 'signal') {
+    if (value !== undefined && !isAbortSignalLike(value)) {
+        throw (0, errors_1.validationError)(`${field} must be an AbortSignal`, field);
+    }
+}
+/**
+ * The keys of a cancellation-only option bag, exhaustive in both directions.
+ *
+ * Every feature's own option-bag lists live in that feature's `internal/`
+ * directory, beside the types they are checked against;
+ * `shared/` knows no feature. This one stays here because `CancelOptions` is
+ * shared by all three. `allKeysOf<T>` keeps the list from drifting from the
+ * type it guards: an exhaustive list compiles, omitting or inventing a key
+ * does not.
+ */
+exports.CANCEL_KEYS = (0, option_shape_1.allKeysOf)({ signal: 'signal' });
+/**
+ * Reject a `{ signal }` bag carrying a key this package does not read.
+ *
+ * Pulled out as one call because several methods across three classes take
+ * only cancellation (`addMessages`, `addMessage`, `clear`,
+ * `reconcileMessageCount`, `deleteThread`, `reconcileVectorIndex`) — one
+ * shared check keeps their wording and their key list from drifting apart.
+ *
+ * Accepts: `options` — as the caller passed it; absent is left alone, since
+ * there is nothing to check.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `options.<key>` for the first key this
+ * package does not read, or `signal` for a value that is not AbortSignal-like.
+ */
+function assertCancelOptions(options) {
+    if (options === undefined)
+        return;
+    (0, option_shape_1.assertShape)(options, exports.CANCEL_KEYS, 'options');
+    assertSignalLike(options.signal);
+}

package/dist/shared/validation/option-shape.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Hides how an option object is told apart from a misspelt one.
+ *
+ * An option type lists its keys once, checked by the compiler against the
+ * type, and an object carrying any other key is refused naming that key. No
+ * caller writes the plain-object test or the unknown-key walk itself, so the
+ * message and the field a refusal names are the same for every option object
+ * this package reads.
+ */
+/**
+ * Every key of `T`, listed once.
+ *
+ * Accepts: an object naming every key of `T` as its own value. The parameter's
+ * type makes the list exhaustive in both directions: omitting a key the type
+ * declares, or naming one it does not, fails to compile — so the list cannot
+ * drift from the option type it guards, which matters because the list is what
+ * decides that a key is *unknown*.
+ *
+ * Returns: the keys.
+ *
+ * Throws: nothing.
+ */
+export declare function allKeysOf<T extends object>(keys: {
+    [K in keyof Required<T>]: K;
+}): readonly string[];
+/**
+ * Whether a value is a plain object: an object at all, not `null`, and not an
+ * array.
+ *
+ * Accepts: `value` — as the caller gave it, `undefined` included.
+ *
+ * Returns: true exactly when {@link assertObjectShape} would accept `value`.
+ * For code that must decide what to do with a malformed value rather than
+ * refuse it on the spot.
+ *
+ * Throws: nothing.
+ */
+export declare function isObjectShape(value: object | undefined): value is object;
+/**
+ * Reject a value that is not a plain object: not an object at all, `null`, or
+ * an array.
+ *
+ * Accepts: `value` — as the caller gave it. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field`.
+ */
+export declare function assertObjectShape(value: object, field: string): void;
+/**
+ * Reject an option object that is not an object, or that carries a key this
+ * package does not read.
+ *
+ * Accepts: `value` — the option object as the caller gave it. `allowed` — the
+ * key list from {@link allKeysOf}. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field` for a value that is not an object, and
+ * `field.key` for an unknown key. A misspelt key is otherwise accepted and
+ * ignored, and the caller runs on a default they believe they overrode.
+ *
+ * `field.key` is **deliberately not cut**, where the rule that bounds an
+ * unchecked string before a message quotes it would otherwise reach it. The
+ * same string is the message *and* `context.field`, and `context.field` is the
+ * compatibility surface a caller branches on, so cutting one and not the other
+ * would make an error disagree with itself about which option it refused.
+ * Cutting both would bound a field callers match on, which this package does
+ * not do. The value is also the caller's own key off the caller's own options
+ * object — neither row-sourced nor third-party — so the only person who can
+ * make it enormous is the person reading the error.
+ */
+export declare function assertShape(value: object, allowed: readonly string[], field: string): void;
+/**
+ * {@link assertShape}, returning `value` instead of nothing.
+ *
+ * Accepts: the same arguments as {@link assertShape}.
+ *
+ * Returns: `value`, unchanged. This returning form exists because a subclass
+ * constructor cannot run a statement before `super(...)`, so validating an
+ * argument bound for `super(...)` has to happen inside that expression —
+ * `super(parseShape(options, ALLOWED, 'options').thing)` — where a `void`
+ * function would not compile.
+ *
+ * Throws: the same as {@link assertShape}.
+ */
+export declare function parseShape<T extends object>(value: T, allowed: readonly string[], field: string): T;

package/dist/shared/validation/option-shape.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Hides how an option object is told apart from a misspelt one.
+ *
+ * An option type lists its keys once, checked by the compiler against the
+ * type, and an object carrying any other key is refused naming that key. No
+ * caller writes the plain-object test or the unknown-key walk itself, so the
+ * message and the field a refusal names are the same for every option object
+ * this package reads.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allKeysOf = allKeysOf;
+exports.isObjectShape = isObjectShape;
+exports.assertObjectShape = assertObjectShape;
+exports.assertShape = assertShape;
+exports.parseShape = parseShape;
+const errors_1 = require("../errors/errors");
+/**
+ * Every key of `T`, listed once.
+ *
+ * Accepts: an object naming every key of `T` as its own value. The parameter's
+ * type makes the list exhaustive in both directions: omitting a key the type
+ * declares, or naming one it does not, fails to compile — so the list cannot
+ * drift from the option type it guards, which matters because the list is what
+ * decides that a key is *unknown*.
+ *
+ * Returns: the keys.
+ *
+ * Throws: nothing.
+ */
+function allKeysOf(keys) {
+    return Object.values(keys);
+}
+/**
+ * Whether a value is a plain object: an object at all, not `null`, and not an
+ * array.
+ *
+ * Accepts: `value` — as the caller gave it, `undefined` included.
+ *
+ * Returns: true exactly when {@link assertObjectShape} would accept `value`.
+ * For code that must decide what to do with a malformed value rather than
+ * refuse it on the spot.
+ *
+ * Throws: nothing.
+ */
+function isObjectShape(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Reject a value that is not a plain object: not an object at all, `null`, or
+ * an array.
+ *
+ * Accepts: `value` — as the caller gave it. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field`.
+ */
+function assertObjectShape(value, field) {
+    if (!isObjectShape(value)) {
+        throw (0, errors_1.validationError)(`${field} must be an object`, field);
+    }
+}
+/**
+ * Reject an option object that is not an object, or that carries a key this
+ * package does not read.
+ *
+ * Accepts: `value` — the option object as the caller gave it. `allowed` — the
+ * key list from {@link allKeysOf}. `field` — what the error names.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `field` for a value that is not an object, and
+ * `field.key` for an unknown key. A misspelt key is otherwise accepted and
+ * ignored, and the caller runs on a default they believe they overrode.
+ *
+ * `field.key` is **deliberately not cut**, where the rule that bounds an
+ * unchecked string before a message quotes it would otherwise reach it. The
+ * same string is the message *and* `context.field`, and `context.field` is the
+ * compatibility surface a caller branches on, so cutting one and not the other
+ * would make an error disagree with itself about which option it refused.
+ * Cutting both would bound a field callers match on, which this package does
+ * not do. The value is also the caller's own key off the caller's own options
+ * object — neither row-sourced nor third-party — so the only person who can
+ * make it enormous is the person reading the error.
+ */
+function assertShape(value, allowed, field) {
+    assertObjectShape(value, field);
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            throw (0, errors_1.validationError)(`${field}.${key} is not an option this package reads; expected one of ${allowed.join(', ')}`, `${field}.${key}`);
+        }
+    }
+}
+/**
+ * {@link assertShape}, returning `value` instead of nothing.
+ *
+ * Accepts: the same arguments as {@link assertShape}.
+ *
+ * Returns: `value`, unchanged. This returning form exists because a subclass
+ * constructor cannot run a statement before `super(...)`, so validating an
+ * argument bound for `super(...)` has to happen inside that expression —
+ * `super(parseShape(options, ALLOWED, 'options').thing)` — where a `void`
+ * function would not compile.
+ *
+ * Throws: the same as {@link assertShape}.
+ */
+function parseShape(value, allowed, field) {
+    assertShape(value, allowed, field);
+    return value;
+}

package/dist/shared/validation/options.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Hides which adapter-wide construction options are accepted.
+ *
+ * The table name, the client choice, the ttl, the retry policy, the recency
+ * index, the read concurrency, compression and S3 offload are checked here with
+ * their bounds, before an adapter builds anything, so a misconfiguration
+ * surfaces at construction rather than on the first call.
+ */
+import type { CompressionConfig } from '../codec/compression';
+import { type S3OffloadConfig } from '../codec/s3/config';
+import type { RetryPolicy } from '../dynamodb/retry';
+import type { BaseAdapterOptions, CodecOptions } from '../options';
+/**
+ * Largest `s3.maxDownloadBytes`/`compression.maxDecompressedBytes` an adapter
+ * accepts (512 MiB): both hold one buffer fully resident while it is read or
+ * inflated, and `BaseAdapterOptions.readConcurrency`'s doc multiplies the two
+ * together into the package's memory ceiling, so an unbounded value here is an
+ * unbounded process, not just an unbounded object.
+ */
+export declare const MAX_PAYLOAD_BUFFER_BYTES: number;
+/** Largest `retry.maxAttempts` an adapter accepts; beyond it a retry loop is a hang, not a policy. */
+export declare const MAX_RETRY_ATTEMPTS = 100;
+/**
+ * Largest `retry.baseDelayMs`/`retry.maxDelayMs` an adapter accepts (one
+ * minute): combined with {@link MAX_RETRY_ATTEMPTS}, an unbounded per-attempt
+ * delay turns a bounded attempt count back into an effectively unbounded wait.
+ */
+export declare const MAX_RETRY_DELAY_MS = 60000;
+/**
+ * Largest `readConcurrency` an adapter accepts: it is a multiplier on the
+ * memory-ceiling formula (see the option's own doc) and on requests fired at
+ * once, so an unbounded value turns a typo into an out-of-memory crash or a
+ * request storm against the table/bucket.
+ */
+export declare const MAX_READ_CONCURRENCY = 128;
+/**
+ * Validate a table name against DynamoDB's own naming rule.
+ *
+ * Accepts: `tableName` — as the caller gave it.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `tableName`.
+ */
+export declare function assertTableName(tableName: string): void;
+/**
+ * Reject a client choice that names two ways of getting one, or a
+ * `clientConfig` that is not an object.
+ *
+ * Accepts: the three client options, from an adapter or from the factory that
+ * defaults them. An injected `client` is used as-is, so a `clientConfig` or
+ * `createClient` given alongside it would be silently ignored — including a
+ * `region` the caller believes is in effect. `clientConfig`, when given, must
+ * be an object that is neither `null` nor an array; what it holds is the AWS
+ * SDK's to judge.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `client` for both ways at once, then
+ * `clientConfig` for one that is not an object.
+ */
+export declare function assertClientChoice(options: Pick<BaseAdapterOptions, 'client' | 'clientConfig' | 'createClient'>): void;
+/**
+ * The three numeric bounds every retry policy shares, regardless of which
+ * other keys the caller's own type allows beyond them. Split out so a caller
+ * with a wider surface than {@link RetryPolicy} (`backfillRecencyIndex`'s
+ * `RetryOptions`, which also exposes `onRetry`, `isRetryable` and friends)
+ * can reuse the identical bounds without going through {@link
+ * assertRetryPolicy}'s narrower `assertShape`, which would refuse those
+ * extra keys outright.
+ *
+ * Accepts: `policy` — its `maxAttempts`, `baseDelayMs` and `maxDelayMs`, each
+ * optional.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `retry.maxAttempts`, `retry.baseDelayMs` or
+ * `retry.maxDelayMs`.
+ */
+export declare function assertRetryBounds(policy: Pick<RetryPolicy, 'maxAttempts' | 'baseDelayMs' | 'maxDelayMs'>): void;
+/**
+ * Validate a retry policy: shape, then each bound.
+ *
+ * Accepts: `policy` — must be an object naming only `maxAttempts`,
+ * `baseDelayMs` and `maxDelayMs`; each, if given, is a bounded integer.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming `retry` or `retry.<key>`.
+ */
+export declare function assertRetryPolicy(policy: RetryPolicy): void;
+/**
+ * Validate the options every adapter shares, at construction.
+ *
+ * Accepts: `options` — must be an object. `tableName` is required; every other
+ * option is optional, and `undefined` means "not configured" for each. A
+ * nested `ttl`, `retry`, `compression` or `s3` must be an object whose keys
+ * this package reads: a misspelt key is rejected rather than ignored, because
+ * the caller would otherwise run on a default they believe they overrode.
+ * `clientConfig` and `s3.clientConfig` must be objects, but their keys belong
+ * to the AWS SDK and are not checked. Keys of `options` itself are not checked
+ * here — the adapter types differ and this validator sees only the shared ones.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` whose `context.field` names the offending option,
+ * dotted for a nested one (`s3.bucketName`). The order is `tableName`, client
+ * choice, `ttl`, `retry`, `compression`, `s3`, `readConcurrency`, then the
+ * index options.
+ *
+ * Guarantees: a misconfiguration surfaces at construction, naming the option,
+ * rather than as a raw AWS error on the first request.
+ */
+export declare function assertBaseAdapterOptions(options: BaseAdapterOptions & CodecOptions): void;
+/**
+ * Validate a `compression` config, honoring its allowed key set.
+ *
+ * Accepts: `config` — an object naming only {@link CompressionConfig}'s keys.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming the offending field, dotted under
+ * `compression`.
+ */
+export declare function assertCompression(config: CompressionConfig): void;
+/**
+ * Validate an `s3` offload config, honoring its allowed key set.
+ *
+ * Accepts: `config` — an object naming only {@link S3OffloadConfig}'s keys.
+ * `config.clientConfig`, when given, must be an object that is neither `null`
+ * nor an array; its own keys are not checked. `config.createS3Client`, when
+ * given, must be a function.
+ *
+ * Returns: nothing: the value is kept under its declared type, and this
+ * checks it.
+ *
+ * Throws: `VALIDATION` naming the offending field, dotted under `s3`.
+ */
+export declare function assertS3(config: S3OffloadConfig): void;