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

package/dist/cjs/shared/dynamodb/table-schema.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_ROW_FORMAT_VERSION = exports.ROW_FORMAT_VERSION = exports.ADAPTER_TAGS = exports.KEY_SEPARATOR = exports.MAX_SORT_KEY_BYTES = exports.MAX_CHECKPOINT_NS_BYTES = exports.MAX_WRITE_CHANNEL_BYTES = exports.MAX_KEY_SEGMENT_BYTES = exports.MAX_PARTITION_ID_BYTES = exports.SORT_KEY_ATTRIBUTE = exports.PARTITION_KEY_ATTRIBUTE = void 0;
+exports.rowKeyOf = rowKeyOf;
+exports.rowVersionOf = rowVersionOf;
+exports.assertReadableRow = assertReadableRow;
+exports.isExpiredRow = isExpiredRow;
+exports.withoutExpired = withoutExpired;
+exports.compareSortKeys = compareSortKeys;
+const base_error_js_1 = require("../errors/base-error.js");
+const error_code_js_1 = require("../errors/error-code.js");
+exports.PARTITION_KEY_ATTRIBUTE = 'PK';
+exports.SORT_KEY_ATTRIBUTE = 'SK';
+exports.MAX_PARTITION_ID_BYTES = 1024;
+exports.MAX_KEY_SEGMENT_BYTES = 256;
+exports.MAX_WRITE_CHANNEL_BYTES = 1024;
+exports.MAX_CHECKPOINT_NS_BYTES = 512;
+exports.MAX_SORT_KEY_BYTES = 1024;
+exports.KEY_SEPARATOR = '#';
+exports.ADAPTER_TAGS = { checkpointer: 'CHKPT', store: 'STORE', history: 'HIST' };
+function rowKeyOf(row) {
+    return { PK: row.PK, SK: row.SK };
+}
+exports.ROW_FORMAT_VERSION = 1;
+exports.SUPPORTED_ROW_FORMAT_VERSION = 1;
+function rowVersionOf(row) {
+    return typeof row.v === 'number' ? row.v : 0;
+}
+function assertReadableRow(row, what) {
+    const version = rowVersionOf(row);
+    if (version <= exports.SUPPORTED_ROW_FORMAT_VERSION)
+        return;
+    throw new base_error_js_1.DynamoDBLangGraphError(`this ${what} row was written in format version ${version}; this version of the library ` +
+        `reads up to ${exports.SUPPORTED_ROW_FORMAT_VERSION} — upgrade to read it`, error_code_js_1.ErrorCode.FORMAT_UNSUPPORTED, { field: 'v' });
+}
+function isExpiredRow(row, nowSeconds) {
+    return row.ttl !== undefined && row.ttl <= nowSeconds;
+}
+const TTL_FILTER = 'attribute_not_exists(#ttl) OR #ttl > :now';
+function withoutExpired(params, nowSeconds) {
+    return {
+        ...params,
+        FilterExpression: params.FilterExpression
+            ? `(${params.FilterExpression}) AND (${TTL_FILTER})`
+            : TTL_FILTER,
+        ExpressionAttributeNames: { ...params.ExpressionAttributeNames, '#ttl': 'ttl' },
+        ExpressionAttributeValues: { ...params.ExpressionAttributeValues, ':now': nowSeconds },
+    };
+}
+function compareSortKeys(left, right) {
+    return Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+}

package/dist/{shared → cjs/shared}/errors/base-error.d.ts

@@ -7,8 +7,8 @@
  * throws — a string, `undefined`, an object — is turned into an `Error` before
  * anything reads it.
  */
-import type { WriteRequest } from '../dynamodb/client';
-import { ErrorCode } from './error-code';
+import type { WriteRequest } from '../dynamodb/client.js';
+import { ErrorCode } from './error-code.js';
 /**
  * Structured, log-safe context attached to every library error. Identifiers
  * and counts only — never a payload or a credential.
@@ -69,7 +69,12 @@ export interface BatchPassDetails {
 export type BatchWriteIncompleteDetails = BatchDrainDetails | BatchPassDetails;
 /** What a `COMPENSATION_FAILED` error reports besides its trigger, which is `cause`. */
 export interface CompensationFailedDetails {
-    /** Why the rollback itself could not finish; itself often a `BATCH_WRITE_INCOMPLETE`. */
+    /**
+     * Why the append could not be undone or settled: the rollback's own
+     * failure (itself often a `BATCH_WRITE_INCOMPLETE`), the read-back's
+     * failure, or the write's own failure when some attempt of it may still
+     * be applied.
+     */
     readonly rollbackError: Error;
 }
 /** The codes that carry details, and the shape each one carries. */
@@ -125,9 +130,11 @@ export type AnyDynamoDBLangGraphError = {
 /**
  * Whether `value` is one of this library's errors.
  *
- * Accepts: any error, from any realm or any copy of this package — and, since
- * the documented place to call this is inside a `catch`, any other value a
- * `throw` can produce: `null`, `undefined`, a string, a number, a symbol.
+ * Accepts: whatever a `catch` clause binds, as it is — an error from any realm
+ * or any copy of this package, and any other value a `throw` can produce:
+ * `null`, `undefined`, a string, a number, a symbol. Declared `unknown`
+ * because that is what `strict` types a `catch` binding, and the documented
+ * place to call this is the first line inside one.
  *
  * Returns: whether it carries the brand, narrowed to the union discriminated by
  * `code`. A symbol registered by name, not `instanceof`: two copies of this
@@ -143,7 +150,7 @@ export type AnyDynamoDBLangGraphError = {
  * a guard that throws inside the `catch` it was called from would replace the
  * failure the caller is reporting with one of its own.
  */
-export declare function isDynamoDBLangGraphError(value: Error): value is AnyDynamoDBLangGraphError;
+export declare function isDynamoDBLangGraphError(value: unknown): value is AnyDynamoDBLangGraphError;
 /**
  * Whether `value` is one of this library's errors carrying `code`.
  *
@@ -157,6 +164,34 @@ export declare function isDynamoDBLangGraphError(value: Error): value is AnyDyna
  * Throws: nothing, for any value.
  */
 export declare function hasErrorCode<C extends ErrorCode>(value: Error, code: C): value is DynamoDBLangGraphError<C>;
+/**
+ * A caller's own copy of a branded error that several concurrent callers would
+ * otherwise share — a cached rejected import, a cached rejected client build.
+ * Sharing the one instance is safe while nothing on the path back to a public
+ * method writes to it, but the public boundary does: it stamps
+ * `context.operation` and `context.tableName`, each independently when the
+ * error does not already carry it, in place, and a second caller reaching the
+ * same shared instance through a *different* public method would then find
+ * the first caller's operation and table already sitting in its own context,
+ * unable to write its own. Giving each
+ * caller its own instance up front — same `message`, `code`, `context` and
+ * `cause` — keeps the two from ever writing to one object. Not a general
+ * clone: an *unbranded* failure needs none, since `wrapForeignError`
+ * (`shared/errors/boundary.ts`) already builds a fresh wrapper for it at
+ * every boundary crossing, unlike a branded error, which crosses unwrapped.
+ *
+ * Accepts: `error` — anything a `catch` can bind.
+ *
+ * Returns: a new `DynamoDBLangGraphError` carrying the same `message`, `code`,
+ * `context`, `cause` and `details` as `error`, when `error` already was one;
+ * `error` itself, unchanged, for anything else. The copy does not carry
+ * `RETRY_EXHAUSTED`'s non-enumerable record of whether a write's retry budget
+ * may still land, so it is not for a budget error: a caller judging one asks
+ * the original.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function copyForCaller(error: Error): Error;
 /**
  * What a log line calls a failure.
  *

package/dist/cjs/shared/errors/base-error.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBLangGraphError = void 0;
+exports.isDynamoDBLangGraphError = isDynamoDBLangGraphError;
+exports.hasErrorCode = hasErrorCode;
+exports.copyForCaller = copyForCaller;
+exports.failureLabel = failureLabel;
+exports.toError = toError;
+const error_code_js_1 = require("./error-code.js");
+const ERROR_BRAND = Symbol.for('@farukada/aws-langgraph-dynamodb-ts/error');
+function isList(field) {
+    return Array.isArray(field);
+}
+function copyDetails(details) {
+    if (details === null || typeof details !== 'object')
+        return details;
+    const fields = Object.entries(details);
+    return Object.fromEntries(fields.map(([key, value]) => [key, isList(value) ? [...value] : value]));
+}
+class DynamoDBLangGraphError extends Error {
+    code;
+    context;
+    constructor(message, code, context = {}, cause, details) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = 'DynamoDBLangGraphError';
+        this.code = code;
+        this.context = { ...context };
+        if (details !== undefined)
+            this.details = copyDetails(details);
+        Object.defineProperty(this, ERROR_BRAND, { value: true, enumerable: false });
+    }
+}
+exports.DynamoDBLangGraphError = DynamoDBLangGraphError;
+function isDynamoDBLangGraphError(value) {
+    return typeof value === 'object' && value !== null && ERROR_BRAND in value;
+}
+function hasErrorCode(value, code) {
+    return isDynamoDBLangGraphError(value) && value.code === code;
+}
+function copyForCaller(error) {
+    if (!isDynamoDBLangGraphError(error))
+        return error;
+    return new DynamoDBLangGraphError(error.message, error.code, error.context, error.cause, error.details);
+}
+function failureLabel(error) {
+    return isDynamoDBLangGraphError(error) ? error.code : error.name;
+}
+function describeThrown(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === undefined || value === null)
+        return `${String(value)} was thrown`;
+    try {
+        return JSON.stringify(value) ?? `a ${typeof value} value was thrown`;
+    }
+    catch {
+        return `an unserializable ${typeof value} value was thrown`;
+    }
+}
+function toError(value) {
+    if (value !== null && typeof value === 'object' && messageOf(value) !== undefined)
+        return value;
+    return new Error(describeThrown(value));
+}
+function messageOf(value) {
+    try {
+        const { message } = value;
+        return typeof message === 'string' ? message : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/{shared → cjs/shared}/errors/boundary.d.ts

@@ -2,30 +2,33 @@
  * Hides what crosses the public boundary.
  *
  * Only this package's own error leaves a public method (record 13): an error of
- * its own passes through with the operation named, and anything else — an SDK
- * failure, a caller's thrown value — is classified and wrapped with its cause
- * attached and its text redacted.
+ * its own passes through, given the public operation and the table it surfaced
+ * through for whichever of the two it does not already name, and anything
+ * else — an SDK failure, a caller's thrown value — is classified and wrapped
+ * with its cause attached and its text redacted.
  */
-import { type AnyDynamoDBLangGraphError, DynamoDBLangGraphError } from './base-error';
+import { type AnyDynamoDBLangGraphError, DynamoDBLangGraphError } from './base-error.js';
 /**
  * Normalise anything escaping a public method into the library's error model.
  *
  * Accepts: anything a `catch` produced — an `Error`, or a value that is not one
- * (`toError` settles that first).
+ * (`toError` settles that first). `operation` — the public method's name.
+ * `tableName` — the adapter's table, when the method has one.
  *
- * Returns: a branded library error unchanged, since its code was assigned
- * closer to the failure and wins; anything else wrapped by
- * {@link wrapForeignError}, with the code the classifier assigns.
+ * Returns: a branded library error — the same one, when it already was one,
+ * with whichever of `context.operation` and `context.tableName` it does not
+ * already carry filled in — or anything else wrapped by {@link wrapForeignError}
+ * with the code the classifier assigns, stamped the same way.
  *
  * Throws: nothing. It runs inside a `catch`, where throwing would discard the
  * failure being reported and replace it with its own.
  */
-export declare function toPublicError(error: Error, operation: string): AnyDynamoDBLangGraphError;
+export declare function toPublicError(error: Error, operation: string, tableName?: string): AnyDynamoDBLangGraphError;
 /**
  * Run a public operation so that every rejection is a library error.
  *
- * Accepts: `operation` — the public method's name, which the wrapped error
- * carries. `fn` — the work.
+ * Accepts: `operation` — the public method's name, which the error carries.
+ * `fn` — the work. `tableName` — the adapter's table, which the error carries.
  *
  * Returns: whatever `fn` resolves to, untouched.
  *
@@ -33,12 +36,12 @@ export declare function toPublicError(error: Error, operation: string): AnyDynam
  * so internal code can keep rethrowing SDK errors verbatim — the retry
  * classifier depends on their shape, and wrapping them early would blind it.
  */
-export declare function guardPublic<T>(operation: string, fn: () => Promise<T>): Promise<T>;
+export declare function guardPublic<T>(operation: string, fn: () => Promise<T>, tableName?: string): Promise<T>;
 /**
  * The same guard for a streaming result.
  *
  * Accepts: `operation` — the public method's name. `source` — the generator to
- * relay.
+ * relay. `tableName` — the adapter's table.
  *
  * Returns: a generator yielding the source's items untouched. A consumer that
  * stops early still closes the source, so an abandoned listing stops reading
@@ -47,7 +50,19 @@ export declare function guardPublic<T>(operation: string, fn: () => Promise<T>):
  * Throws: a library error, always — including for a failure raised
  * mid-iteration, which is the case a `try` around the loop body would miss.
  */
-export declare function guardPublicIterable<T>(operation: string, source: AsyncGenerator<T>): AsyncGenerator<T>;
+export declare function guardPublicIterable<T>(operation: string, source: AsyncGenerator<T>, tableName?: string): AsyncGenerator<T>;
+/**
+ * The same guard for a synchronous public method.
+ *
+ * Accepts: `operation` — the public method's name. `fn` — the work.
+ * `tableName` — the adapter's table.
+ *
+ * Returns: whatever `fn` returns.
+ *
+ * Throws: a library error, always — what a client's own `destroy` threw
+ * included, classified like any other foreign failure and kept as `cause`.
+ */
+export declare function guardPublicSync<T>(operation: string, fn: () => T, tableName?: string): T;
 /**
  * A failure from below this library, as one of its errors.
  *

package/dist/cjs/shared/errors/boundary.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPublicError = toPublicError;
+exports.guardPublic = guardPublic;
+exports.guardPublicIterable = guardPublicIterable;
+exports.guardPublicSync = guardPublicSync;
+exports.wrapForeignError = wrapForeignError;
+const secret_patterns_js_1 = require("../logging/secret-patterns.js");
+const truncate_js_1 = require("../logging/truncate.js");
+const base_error_js_1 = require("./base-error.js");
+const classify_js_1 = require("./classify.js");
+function stampContext(error, operation, tableName) {
+    const context = error.context;
+    if (typeof context !== 'object' || context === null)
+        return;
+    try {
+        context.operation ??= operation;
+        if (tableName !== undefined)
+            context.tableName ??= tableName;
+    }
+    catch {
+    }
+}
+function toPublicError(error, operation, tableName) {
+    const normalized = (0, base_error_js_1.toError)(error);
+    const publicError = (0, base_error_js_1.isDynamoDBLangGraphError)(normalized)
+        ? normalized
+        : wrapForeignError(normalized, operation);
+    stampContext(publicError, operation, tableName);
+    return publicError;
+}
+async function guardPublic(operation, fn, tableName) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+async function* guardPublicIterable(operation, source, tableName) {
+    try {
+        for await (const item of source)
+            yield item;
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+function guardPublicSync(operation, fn, tableName) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        throw toPublicError(error, operation, tableName);
+    }
+}
+function wrapForeignError(cause, operation) {
+    const below = (0, base_error_js_1.toError)(cause);
+    const classifiable = (0, classify_js_1.classifiableCause)(below);
+    return new base_error_js_1.DynamoDBLangGraphError(`${operation}: ${(0, truncate_js_1.truncateForLog)(below.name)}: ${(0, secret_patterns_js_1.redactedMessage)(below)}`, (0, classify_js_1.classifyAwsError)(classifiable), { operation, ...(0, classify_js_1.awsDiagnostics)(classifiable) }, below);
+}

package/dist/cjs/shared/errors/classify.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Hides which AWS failures are the same failure.
+ *
+ * An SDK error arrives as a name, an HTTP status, a Node network `code` or —
+ * for a cancelled transaction — a list of per-item reasons, and several of
+ * those arrivals mean one thing to a caller deciding what to do. Their mapping
+ * to one `ErrorCode`, and the retry layer's default list of transient names,
+ * come from one table here (record 19), so no call site compares an AWS
+ * exception name of its own.
+ */
+import type { ErrorContext } from './base-error.js';
+import { ErrorCode } from './error-code.js';
+/** The fields an AWS SDK v3 error, or a transport error under it, can carry. */
+/** The fields of an SDK error this module reads; exported for the retry layer's own walk. */
+export interface AwsErrorFields {
+    name?: string;
+    code?: string;
+    message?: string;
+    $metadata?: {
+        httpStatusCode?: number;
+        requestId?: string;
+        clockSkewCorrected?: boolean;
+    } | null;
+}
+/**
+ * The Node.js system error codes the SDK's own retry strategy treats as
+ * transient regardless of name (`@smithy/core` retry `NODEJS_TIMEOUT_ERROR_CODES`
+ * and `NODEJS_NETWORK_ERROR_CODES`). Matched on the error's own `code`.
+ */
+export declare const TRANSIENT_NETWORK_ERROR_CODES: readonly string[];
+/**
+ * HTTP statuses the SDK retries regardless of name: throttling (429) and the
+ * transient server statuses (`@smithy/core` retry `TRANSIENT_ERROR_STATUS_CODES`).
+ * They classify an error the SDK could not map to a modeled exception, which
+ * arrives as `name: 'Unknown'` with only its status.
+ */
+export declare const TRANSIENT_HTTP_STATUSES: readonly number[];
+/**
+ * AWS error name to code. Each name is declared by the installed
+ * `@aws-sdk/client-dynamodb` or `@aws-sdk/client-s3`, or documented on a page
+ * `test/static/aws-error-names.test.ts` cites; that test fails on any other.
+ */
+export declare const AWS_ERROR_CODES: Readonly<Record<string, ErrorCode>>;
+/**
+ * The retry layer's default tokens: every name {@link AWS_ERROR_CODES} maps to
+ * a retryable code, and the network codes. Derived rather than listed, so the
+ * retry layer and the code a caller sees share one list of transient names.
+ * They differ at two edges: the retry layer also retries on the SDK's
+ * `$retryable` trait, which {@link classifyAwsError} does not read, and it
+ * walks the cause chain matching `errno` and `syscall` too, where the
+ * classifier reads one error's `name`, `code` and status.
+ */
+export declare const DEFAULT_RETRYABLE_ERRORS: readonly string[];
+/**
+ * Whether the SDK itself would retry this signing failure.
+ *
+ * Accepts: `fields` — an error's own fields, as the SDK sets them.
+ *
+ * Returns: true when the SDK corrected its clock offset on the response
+ * (`$metadata.clockSkewCorrected`, set once the skew passes four minutes), or
+ * the service reports the signature expired (`InvalidSignatureException`
+ * saying so) — the SDK's own `isTransientError`, kept here because this
+ * package switches the SDK's retries off and would otherwise fail a host
+ * whose clock drifts on its first request, where a stock client recovers on
+ * the next.
+ *
+ * Throws: nothing.
+ */
+export declare function isCorrectedClockSkew(fields: AwsErrorFields): boolean;
+/**
+ * The code a failure that is not one of this library's own belongs to.
+ *
+ * Accepts: anything a `catch` can bind — an SDK error, a transport error, a
+ * value from caller-supplied code, `null`, a string.
+ *
+ * Returns: a transaction cancellation's code from its reasons (a sole
+ * `ConditionalCheckFailed` cause is `CONDITION_CONFLICT`; all-transient causes
+ * are `THROTTLED` or `CONTENTION`); otherwise `SERVICE_UNAVAILABLE` for a
+ * signing failure the SDK corrected its clock for or reports expired
+ * ({@link isCorrectedClockSkew}); otherwise the table's code for the error's
+ * own `name`; otherwise `SERVICE_UNAVAILABLE` for a transient network `code`;
+ * otherwise by HTTP status — 412 `CONDITION_CONFLICT`, 429 `THROTTLED`,
+ * 500/502/503/504 `SERVICE_UNAVAILABLE`; otherwise `AWS_REQUEST_FAILED` for an
+ * AWS-shaped error and `UNEXPECTED_ERROR` for anything else. Only the error's
+ * own fields are read, never its `cause`.
+ *
+ * Throws: nothing, for any value. It runs inside `catch` blocks.
+ */
+export declare function classifyAwsError(error: Error): ErrorCode;
+/**
+ * How far a walk down a cause chain goes before giving up: deep enough for
+ * any chain a real failure builds, and a bound in case a `cause` loops
+ * through objects a `Set` of seen nodes cannot pair. Shared by
+ * {@link classifiableCause} and the retry layer's own walk.
+ */
+export declare const MAX_CAUSE_DEPTH = 32;
+/**
+ * The node in `error`'s own cause chain — `error` itself, then its `cause`,
+ * then that error's own `cause`, and so on — that {@link classifyAwsError}
+ * does not answer `UNEXPECTED_ERROR` for.
+ *
+ * Accepts: `error` — the outermost failure to classify, already normalised by
+ * `toError`.
+ *
+ * Returns: the first node the classifier places under an AWS or network code,
+ * so a caller's own error wrapping a modeled SDK exception, an SDK error whose
+ * own `cause` is a raw transport failure, or a `RETRY_EXHAUSTED` error wrapping
+ * either as its own `cause`, still classifies — and still yields diagnostics —
+ * on the AWS/network failure underneath rather than losing it one level up —
+ * the same failure the retry layer's cause-chain walk (`isRetryableError` in
+ * `shared/dynamodb/retry.ts`) already sees. `error` itself when nothing in its
+ * chain classifies either. The walk gives up after {@link MAX_CAUSE_DEPTH}
+ * nodes, and a cycle in the chain stops it rather than looping, exactly as
+ * that other walk does.
+ *
+ * Throws: nothing, for any value `toError` can produce.
+ */
+export declare function classifiableCause(error: Error): Error;
+/**
+ * The fields an operator needs first, lifted off an AWS-shaped error.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: `awsErrorName`, `requestId` and `httpStatusCode`, each only when
+ * present and well-typed, for an error carrying `$metadata` or a name the table
+ * knows or that ends in `Exception`; `{}` for anything else — a bare network
+ * failure included, since it may be a caller's own connection rather than AWS's.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function awsDiagnostics(error: Error): Pick<ErrorContext, 'awsErrorName' | 'requestId' | 'httpStatusCode'>;
+/**
+ * Whether a failed request ended on this side, before the service answered it.
+ *
+ * Accepts: anything a `catch` can bind, and `undefined`.
+ *
+ * Returns: true when the failure, or a cause beneath it, is a cut this side
+ * made — the SDK's own `TimeoutError` or `AbortError`, or a Node network error
+ * such as `ECONNRESET` or `ETIMEDOUT` — and no node on the way carries the HTTP
+ * status of a response. The service may still apply a request cut that way
+ * after the caller has stopped waiting for it. False for everything else: a
+ * failure the service answered, and one that says nothing about the transport,
+ * such as a value a caller's own code threw. A cycle in the chain ends the walk.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function endedWithoutAnswer(error: Error | undefined): boolean;
+/**
+ * Whether one attempt's own failure leaves DynamoDB free to apply it later,
+ * judged from that attempt alone.
+ *
+ * Accepts: anything a `catch` can bind, and `undefined`.
+ *
+ * Returns: true when the attempt {@link endedWithoutAnswer}; when the service
+ * answered that its own earlier attempt under the same `ClientRequestToken`
+ * was still being processed (`TransactionInProgressException`); or when it
+ * answered with a server error, an HTTP 5xx. AWS says of a 500
+ * (`InternalServerError`) that the request "may have succeeded or failed", with
+ * no later point documented as settling it (DynamoDB Developer Guide, *Error
+ * handling*:
+ * https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.Errors.html);
+ * this library treats every 5xx the same way. False for a refusal, a throttle,
+ * or any other definite answer.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function mayStillBeInFlight(error: Error | undefined): boolean;
+/**
+ * Whether the service refused a request outright, so that none of it was applied.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for a cancelled transaction — DynamoDB applies none of a
+ * transaction it cancels — and for a failure the classifier places under a
+ * refusal: a malformed request, a denied permission, a missing table or index,
+ * a failed condition. False for everything else, a spent retry budget and a
+ * cancel included, since neither says what the service did.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function refusedByService(error: Error): boolean;
+/**
+ * Whether an S3 read failed because the object is gone.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for `NoSuchKey` only. `NOT_FOUND` also covers a missing
+ * bucket, which is a configuration fault; reading it as a lost payload would
+ * write off data that is still there.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function isMissingObject(error: Error): boolean;
+/**
+ * Whether reading a bucket's lifecycle configuration failed because the bucket
+ * has none.
+ *
+ * Accepts: anything a `catch` can bind.
+ *
+ * Returns: true for `NoSuchLifecycleConfiguration` only. `NOT_FOUND` also
+ * covers a missing bucket, table or object; reading one of those as "no rules
+ * yet" would start a rule set for a bucket that is not there.
+ *
+ * Throws: nothing, for any value.
+ */
+export declare function isMissingLifecycleConfiguration(error: Error): boolean;