@giveitsmaller/sdk 0.4.0 → 0.7.0

package/dist/errors.js

@@ -67,6 +67,39 @@ export class GislFeatureNotAvailableError extends GislApiError {
         this.name = 'GislFeatureNotAvailableError';
     }
 }
+/**
+ * 422 response on `POST /api/workflows` when a job references an upload
+ * whose server-side probe hasn't completed at workflow-create time. The
+ * server rejects rather than silently routing as `short_form` (which
+ * hard-fails long video clips).
+ *
+ * **Recovery contract** (per contracts ProbePendingResponse docblock):
+ * poll `POST /api/uploads/{id}/probe` for the pending upload until
+ * `probe_status` is terminal (`ok` → re-`POST /api/workflows` the same
+ * request; `corrupt` / `unsupported_codec` → surface the probe error).
+ * The `Retry-After` response header (when present) suggests a delay
+ * in seconds before the next poll/retry.
+ *
+ * `payload.jobRef` identifies which job in the multi-job request triggered
+ * the probe-pending rejection.
+ *
+ * @example
+ * try {
+ *   await client.createWorkflow({ jobs });
+ * } catch (e) {
+ *   if (e instanceof GislProbePendingError) {
+ *     await waitForProbe(e.payload.jobRef);
+ *     // retry...
+ *   }
+ *   throw e;
+ * }
+ */
+export class GislProbePendingError extends GislApiError {
+    constructor(statusCode, errorMessage, payload, path, extra) {
+        super(statusCode, errorMessage, path, undefined, buildOptionsWithPayload(payload, extra));
+        this.name = 'GislProbePendingError';
+    }
+}
 export class GislWorkflowExpiredError extends GislApiError {
     constructor(statusCode, errorMessage, payload, path, extra) {
         super(statusCode, errorMessage, path, undefined, buildOptionsWithPayload(payload, extra));
@@ -79,6 +112,208 @@ export class GislAuthError extends GislApiError {
         this.name = 'GislAuthError';
     }
 }
+/**
+ * A single class covering all three "upload exceeds a size/duration cap"
+ * responses (422 size-tier, 422 duration-tier, 413 absolute).
+ *
+ * CONSCIOUS DEVIATION from the one-typed-payload-per-class invariant that the
+ * other structured subclasses follow (`GislBalanceExhaustedError`,
+ * `GislWorkflowExpiredError`, …). Justification: the card mandates this single
+ * `GislUploadCapExceededError` name and SDK-3 / E2E-1 are blocked-on it, so
+ * splitting into size/duration subclasses would break a cross-ticket naming
+ * contract; and 413 carries no typed envelope at all (plain `ErrorEnvelope`),
+ * so a one-payload-per-class split could not cover it uniformly anyway. The
+ * `kind` discriminant + a union-typed (possibly absent) `payload` is the
+ * deliberate trade-off. This is the only structured error in the tree that
+ * does not bind exactly one payload type — documented here in the same spirit
+ * as the inline PHP↔TS divergence notes.
+ *
+ * The two multipart-part errors below are deliberately NOT folded in with a
+ * `kind`: they carry different fields (`partNumber`/`uploadId` for an instance
+ * PUT failure vs `requiredParts`/`maxParts` for the count-ceiling guard) and
+ * are thrown from the multipart path, not the response handler.
+ */
+export class GislUploadCapExceededError extends GislApiError {
+    kind;
+    constructor(statusCode, errorMessage, kind, payload, path, extra) {
+        super(statusCode, errorMessage, path, undefined, buildOptionsWithPayload(payload, extra));
+        this.name = 'GislUploadCapExceededError';
+        this.kind = kind;
+    }
+}
+/**
+ * 404 `MULTIPART_SESSION_NOT_FOUND` — the durable multipart session referenced
+ * by a resume / status / presign / keepalive call cannot be located (expired
+ * past its 48h manifest TTL, deleted, or never existed). Thrown by the SDK-3
+ * resume-support endpoints (`getUploadStatus`, `presignParts`,
+ * `keepaliveUpload`, and the resume branch of `uploadFile`).
+ *
+ * Carries no typed structured payload — the contract for the 3 resume-support
+ * endpoints models this code as a plain `ErrorEnvelope`. Consumers should
+ * detect via `instanceof` and abandon the resume; a fresh `uploadFile()` call
+ * (without `resumeUploadId`) will start a new session.
+ */
+export class GislMultipartSessionNotFoundError extends GislApiError {
+    constructor(statusCode, errorMessage, path, options) {
+        super(statusCode, errorMessage, path, undefined, options);
+        this.name = 'GislMultipartSessionNotFoundError';
+    }
+}
+/**
+ * 403 `MULTIPART_SESSION_OWNERSHIP` — the caller is authenticated but the
+ * multipart session belongs to a different user. Thrown by the SDK-3
+ * resume-support endpoints. The session itself exists (otherwise the server
+ * would return 404 NOT_FOUND); the caller's identity simply doesn't match
+ * `manifest.userId`. Consumers should abandon the resume.
+ */
+export class GislMultipartSessionOwnershipError extends GislApiError {
+    constructor(statusCode, errorMessage, path, options) {
+        super(statusCode, errorMessage, path, undefined, options);
+        this.name = 'GislMultipartSessionOwnershipError';
+    }
+}
+/**
+ * 403 `MULTIPART_SESSION_AUTH_REQUIRED` — the multipart session was initiated
+ * anonymously (no `manifest.userId`) and the SDK-3 resume-support endpoints
+ * refuse to serve it on an authed caller. There is no "claim" workflow today
+ * to bind an authed identity to an anonymously-started session; that is the
+ * future flip tracked at upstream ticket 8LABloaz. Consumers hitting this on
+ * resume should abandon and re-upload from scratch under the authed identity.
+ */
+export class GislMultipartSessionAuthRequiredError extends GislApiError {
+    constructor(statusCode, errorMessage, path, options) {
+        super(statusCode, errorMessage, path, undefined, options);
+        this.name = 'GislMultipartSessionAuthRequiredError';
+    }
+}
+/**
+ * Root of the LOCAL config-error tree — thrown before any HTTP/file I/O.
+ * Sibling of `GislApiError` (which represents server-side error envelopes).
+ * Reserve for fail-early errors raised by the ergonomic-layer factory or
+ * credential-chain resolver when the caller hasn't supplied something the
+ * SDK needs to make a request. Never carries an HTTP status code.
+ *
+ * Optional `metadata` (T4b — `27rE1fZn`) carries structured fields used
+ * by the preset resolver and other ergonomic-layer validators. Existing
+ * call sites that pass `(message)` keep working — metadata is purely
+ * additive and defaults to `undefined`.
+ */
+export class GislConfigError extends GislError {
+    reason;
+    conflictingFields;
+    resolvedSnapshot;
+    suggestion;
+    constructor(message, metadata) {
+        super(message);
+        this.name = 'GislConfigError';
+        if (metadata !== undefined) {
+            if (metadata.reason !== undefined)
+                this.reason = metadata.reason;
+            if (metadata.conflictingFields !== undefined) {
+                this.conflictingFields = metadata.conflictingFields;
+            }
+            if (metadata.resolvedSnapshot !== undefined) {
+                this.resolvedSnapshot = metadata.resolvedSnapshot;
+            }
+            if (metadata.suggestion !== undefined)
+                this.suggestion = metadata.suggestion;
+        }
+    }
+}
+/**
+ * The ergonomic-layer factory `gisl.create()` could not resolve an API key
+ * from any of explicit arg, `GISL_API_KEY` env, or shared-config profile,
+ * AND the caller did not opt into anonymous or cookie-mode. Thrown BEFORE
+ * any file read or HTTP request — calls to `client.compress(...)`, `.run()`,
+ * etc., synchronously fail with this error.
+ */
+export class GislMissingCredentialsError extends GislConfigError {
+    constructor(message) {
+        super(message);
+        this.name = 'GislMissingCredentialsError';
+    }
+}
+/**
+ * The caller used `gisl.anonymous()` and then invoked an operation that is
+ * not in the anonymous-capable allowlist. Local-only — thrown before any I/O.
+ * Distinct from server-side `GislAuthError` (401/403 on the wire).
+ */
+export class GislFeatureRequiresAuthError extends GislConfigError {
+    operation;
+    constructor(operation, message) {
+        super(message);
+        this.name = 'GislFeatureRequiresAuthError';
+        this.operation = operation;
+    }
+}
+/**
+ * `MergeBuilder.sequence(...)` referenced an asset that wasn't declared in
+ * the prior `client.merge(...)` call. Local validation runs BEFORE upload
+ * so the caller fails fast on the typo without burning bandwidth.
+ */
+export class GislUndeclaredAssetError extends GislConfigError {
+    assetId;
+    declaredAssets;
+    constructor(assetId, declaredAssets) {
+        super(`Sequence references asset '${assetId}' but it wasn't declared in merge(...). ` +
+            `Declared assets: [${declaredAssets.join(', ')}]. ` +
+            `Either pass it to merge(...) before sequencing, or remove the reference.`);
+        this.name = 'GislUndeclaredAssetError';
+        this.assetId = assetId;
+        this.declaredAssets = declaredAssets;
+    }
+}
+/**
+ * `MergeBuilder.sequence(...)` was called but at least one declared asset
+ * wasn't referenced. Almost always a bug (wasted upload). Escape via
+ * `allowUnusedAssets: true` on the merge options.
+ */
+export class GislUnusedAssetError extends GislConfigError {
+    unusedAssets;
+    constructor(unusedAssets) {
+        super(`Assets [${unusedAssets.join(', ')}] were declared in merge(...) but never sequenced. ` +
+            `Reference them in .sequence(...), remove them from the declaration, ` +
+            `or pass {allowUnusedAssets: true} to opt out of this check.`);
+        this.name = 'GislUnusedAssetError';
+        this.unusedAssets = unusedAssets;
+    }
+}
+/**
+ * `MergeBuilder.sequence(...)` on an image merge was given a `clip(ref, opts)`
+ * entry. Image merges have NO per-input options in the wire today — `transition`
+ * applies at the merge level and is uniform across all joins.
+ */
+export class GislPerInputOptionsNotSupportedError extends GislConfigError {
+    mediaKind;
+    constructor(mediaKind) {
+        super(`${mediaKind} merge has no per-input options today; set 'transition' at the ` +
+            `.merge(...) level instead — it applies to every join.`);
+        this.name = 'GislPerInputOptionsNotSupportedError';
+        this.mediaKind = mediaKind;
+    }
+}
+/**
+ * Thrown by future chain methods (`.compress()` / `.thumbnail()` /
+ * `.convert()` on an `OperationBuilder`) when the previous step produces
+ * MULTIPLE artifacts and the caller didn't explicitly call `.mapEach(...)`
+ * to opt into per-artifact fan-out. T6 ships the error class + the
+ * `.mapEach(...)` method; the chain methods themselves are a separate
+ * follow-up card, so this error is currently dormant — but the type +
+ * audit-gate registration land here so the future chain-method PR is a
+ * pure addition with no public-API churn.
+ */
+export class GislChainCardinalityMismatchError extends GislConfigError {
+    previousOperation;
+    attemptedOperation;
+    constructor(previousOperation, attemptedOperation) {
+        super(`Previous step (${previousOperation}) produces multiple artifacts; ` +
+            `use .mapEach(art => art.${attemptedOperation}(...)) to apply the chain per-artifact, ` +
+            `or branch to a single artifact first.`);
+        this.name = 'GislChainCardinalityMismatchError';
+        this.previousOperation = previousOperation;
+        this.attemptedOperation = attemptedOperation;
+    }
+}
 export class GislTimeoutError extends GislError {
     constructor(message) {
         super(message);
@@ -91,3 +326,36 @@ export class GislAbortError extends GislError {
         this.name = 'GislAbortError';
     }
 }
+/**
+ * A single S3 multipart part PUT failed terminally (after the configured
+ * retry attempts) or could not be read. Subclasses `GislError` — NOT
+ * `GislApiError` — because it carries no contract error envelope and is
+ * thrown from the multipart upload path, never from the response handler.
+ * Mirrors the `GislAbortError` shape, plus the failing part's identifiers.
+ */
+export class GislMultipartPartError extends GislError {
+    partNumber;
+    uploadId;
+    constructor(message, partNumber, uploadId) {
+        super(message);
+        this.name = 'GislMultipartPartError';
+        this.partNumber = partNumber;
+        this.uploadId = uploadId;
+    }
+}
+/**
+ * The upload would require more than the S3 hard limit of 10 000 multipart
+ * parts at the server-provided chunk size. Client-side guard (Model A: the
+ * server computes the part plan; the SDK asserts the ceiling). Subclasses
+ * `GislError` for the same reason as `GislMultipartPartError`.
+ */
+export class GislMultipartPartCountError extends GislError {
+    requiredParts;
+    maxParts;
+    constructor(message, requiredParts, maxParts) {
+        super(message);
+        this.name = 'GislMultipartPartCountError';
+        this.requiredParts = requiredParts;
+        this.maxParts = maxParts;
+    }
+}

package/dist/generated/sdk_spec/enums.d.ts

@@ -0,0 +1,195 @@
+export declare const OptimizeFor: {
+    readonly Size: "Size";
+    readonly Balanced: "Balanced";
+    readonly Quality: "Quality";
+};
+export type OptimizeFor = typeof OptimizeFor[keyof typeof OptimizeFor];
+export declare const ImageMode: {
+    readonly Lossy: "lossy";
+    readonly Lossless: "lossless";
+    readonly Auto: "auto";
+};
+export type ImageMode = typeof ImageMode[keyof typeof ImageMode];
+export declare const ImageFormat: {
+    readonly Original: "original";
+    readonly Auto: "auto";
+    readonly Smallest: "smallest";
+    readonly Jpeg: "jpeg";
+    readonly Png: "png";
+    readonly Webp: "webp";
+    readonly Avif: "avif";
+};
+export type ImageFormat = typeof ImageFormat[keyof typeof ImageFormat];
+export declare const ImageFit: {
+    readonly Max: "max";
+    readonly Crop: "crop";
+    readonly Scale: "scale";
+};
+export type ImageFit = typeof ImageFit[keyof typeof ImageFit];
+export declare const ImageMetadataPolicy: {
+    readonly All: "all";
+    readonly None: "none";
+    readonly Copyright: "copyright";
+    readonly Sensitive: "sensitive";
+};
+export type ImageMetadataPolicy = typeof ImageMetadataPolicy[keyof typeof ImageMetadataPolicy];
+export declare const IccProfilePolicy: {
+    readonly Preserve: "preserve";
+    readonly Strip: "strip";
+    readonly Srgb: "srgb";
+};
+export type IccProfilePolicy = typeof IccProfilePolicy[keyof typeof IccProfilePolicy];
+export declare const VideoCodec: {
+    readonly H264: "h264";
+    readonly H265: "h265";
+    readonly Vp9: "vp9";
+    readonly Av1: "av1";
+};
+export type VideoCodec = typeof VideoCodec[keyof typeof VideoCodec];
+export declare const VideoPreset: {
+    readonly Ultrafast: "ultrafast";
+    readonly Superfast: "superfast";
+    readonly Veryfast: "veryfast";
+    readonly Faster: "faster";
+    readonly Fast: "fast";
+    readonly Medium: "medium";
+    readonly Slow: "slow";
+    readonly Slower: "slower";
+    readonly Veryslow: "veryslow";
+};
+export type VideoPreset = typeof VideoPreset[keyof typeof VideoPreset];
+export declare const VideoFit: {
+    readonly Max: "max";
+    readonly Crop: "crop";
+    readonly Scale: "scale";
+    readonly Pad: "pad";
+};
+export type VideoFit = typeof VideoFit[keyof typeof VideoFit];
+export declare const AudioBitrate: {
+    readonly _64: 64;
+    readonly _96: 96;
+    readonly _128: 128;
+    readonly _192: 192;
+    readonly _256: 256;
+    readonly _320: 320;
+};
+export type AudioBitrate = typeof AudioBitrate[keyof typeof AudioBitrate];
+export declare const AudioCodec: {
+    readonly Aac: "aac";
+    readonly Opus: "opus";
+    readonly Vorbis: "vorbis";
+    readonly Copy: "copy";
+};
+export type AudioCodec = typeof AudioCodec[keyof typeof AudioCodec];
+export declare const AudioSampleRate: {
+    readonly _22050: 22050;
+    readonly _44100: 44100;
+    readonly _48000: 48000;
+};
+export type AudioSampleRate = typeof AudioSampleRate[keyof typeof AudioSampleRate];
+export declare const PdfProfile: {
+    readonly Web: "web";
+    readonly Print: "print";
+    readonly Archive: "archive";
+    readonly Max: "max";
+};
+export type PdfProfile = typeof PdfProfile[keyof typeof PdfProfile];
+export declare const PdfColorspace: {
+    readonly Unchanged: "unchanged";
+    readonly Rgb: "rgb";
+    readonly Cmyk: "cmyk";
+    readonly Grayscale: "grayscale";
+};
+export type PdfColorspace = typeof PdfColorspace[keyof typeof PdfColorspace];
+/** Catalog of every ergonomic enum (canonicalName → wire). */
+export declare const ERGONOMIC_ENUMS: {
+    readonly OptimizeFor: {
+        readonly Size: "Size";
+        readonly Balanced: "Balanced";
+        readonly Quality: "Quality";
+    };
+    readonly ImageMode: {
+        readonly Lossy: "lossy";
+        readonly Lossless: "lossless";
+        readonly Auto: "auto";
+    };
+    readonly ImageFormat: {
+        readonly Original: "original";
+        readonly Auto: "auto";
+        readonly Smallest: "smallest";
+        readonly Jpeg: "jpeg";
+        readonly Png: "png";
+        readonly Webp: "webp";
+        readonly Avif: "avif";
+    };
+    readonly ImageFit: {
+        readonly Max: "max";
+        readonly Crop: "crop";
+        readonly Scale: "scale";
+    };
+    readonly ImageMetadataPolicy: {
+        readonly All: "all";
+        readonly None: "none";
+        readonly Copyright: "copyright";
+        readonly Sensitive: "sensitive";
+    };
+    readonly IccProfilePolicy: {
+        readonly Preserve: "preserve";
+        readonly Strip: "strip";
+        readonly Srgb: "srgb";
+    };
+    readonly VideoCodec: {
+        readonly H264: "h264";
+        readonly H265: "h265";
+        readonly Vp9: "vp9";
+        readonly Av1: "av1";
+    };
+    readonly VideoPreset: {
+        readonly Ultrafast: "ultrafast";
+        readonly Superfast: "superfast";
+        readonly Veryfast: "veryfast";
+        readonly Faster: "faster";
+        readonly Fast: "fast";
+        readonly Medium: "medium";
+        readonly Slow: "slow";
+        readonly Slower: "slower";
+        readonly Veryslow: "veryslow";
+    };
+    readonly VideoFit: {
+        readonly Max: "max";
+        readonly Crop: "crop";
+        readonly Scale: "scale";
+        readonly Pad: "pad";
+    };
+    readonly AudioBitrate: {
+        readonly _64: 64;
+        readonly _96: 96;
+        readonly _128: 128;
+        readonly _192: 192;
+        readonly _256: 256;
+        readonly _320: 320;
+    };
+    readonly AudioCodec: {
+        readonly Aac: "aac";
+        readonly Opus: "opus";
+        readonly Vorbis: "vorbis";
+        readonly Copy: "copy";
+    };
+    readonly AudioSampleRate: {
+        readonly _22050: 22050;
+        readonly _44100: 44100;
+        readonly _48000: 48000;
+    };
+    readonly PdfProfile: {
+        readonly Web: "web";
+        readonly Print: "print";
+        readonly Archive: "archive";
+        readonly Max: "max";
+    };
+    readonly PdfColorspace: {
+        readonly Unchanged: "unchanged";
+        readonly Rgb: "rgb";
+        readonly Cmyk: "cmyk";
+        readonly Grayscale: "grayscale";
+    };
+};

package/dist/generated/sdk_spec/enums.js

@@ -0,0 +1,127 @@
+// CODE GENERATED — DO NOT EDIT.
+// Source: compression_contracts/sdk-spec/ (see sdk-spec/README.md).
+// Regenerate with: scripts/generate.py.
+// Top-level preset selector. Resolved client-side to concrete wire fields per presets.yaml.
+export const OptimizeFor = {
+    Size: "Size",
+    Balanced: "Balanced",
+    Quality: "Quality",
+};
+// Image compression algorithm. lossy = smaller file; lossless = no quality loss; auto = format-best.
+export const ImageMode = {
+    Lossy: "lossy",
+    Lossless: "lossless",
+    Auto: "auto",
+};
+// Image output format selection. Original keeps input; Auto picks best per browser support; Smallest tries all and returns smallest.
+export const ImageFormat = {
+    Original: "original",
+    Auto: "auto",
+    Smallest: "smallest",
+    Jpeg: "jpeg",
+    Png: "png",
+    Webp: "webp",
+    Avif: "avif",
+};
+// Image resize mode. Only applies when width or height is set (depends_on width/height in compress.yaml).
+export const ImageFit = {
+    Max: "max",
+    Crop: "crop",
+    Scale: "scale",
+};
+// Image metadata handling. Counter-intuitive wire naming:
+//   All       = strip everything (smallest file)
+//   None      = keep all EXIF/IPTC/XMP
+//   Copyright = keep only copyright/author fields
+//   Sensitive = keep EXIF but strip GPS/location (GDPR-friendly)
+export const ImageMetadataPolicy = {
+    All: "all",
+    None: "none",
+    Copyright: "copyright",
+    Sensitive: "sensitive",
+};
+// ICC color profile handling.
+export const IccProfilePolicy = {
+    Preserve: "preserve",
+    Strip: "strip",
+    Srgb: "srgb",
+};
+// Video codec. H264 = widest compatibility; H265/Av1 = better compression but slower.
+export const VideoCodec = {
+    H264: "h264",
+    H265: "h265",
+    Vp9: "vp9",
+    Av1: "av1",
+};
+// Encoding speed vs compression ratio trade-off (FFmpeg-style x264/x265 preset names).
+export const VideoPreset = {
+    Ultrafast: "ultrafast",
+    Superfast: "superfast",
+    Veryfast: "veryfast",
+    Faster: "faster",
+    Fast: "fast",
+    Medium: "medium",
+    Slow: "slow",
+    Slower: "slower",
+    Veryslow: "veryslow",
+};
+// Video resize mode. Only applies when width or height is set. Pad is video-only (image fit lacks pad).
+export const VideoFit = {
+    Max: "max",
+    Crop: "crop",
+    Scale: "scale",
+    Pad: "pad",
+};
+// Audio output bitrate in kbps. Shared between compress (audio + video.audioBitrate) cells.
+export const AudioBitrate = {
+    _64: 64,
+    _96: 96,
+    _128: 128,
+    _192: 192,
+    _256: 256,
+    _320: 320,
+};
+// Audio codec. Aac = widest compatibility; Opus = best quality/size; Copy = passthrough (no re-encode).
+export const AudioCodec = {
+    Aac: "aac",
+    Opus: "opus",
+    Vorbis: "vorbis",
+    Copy: "copy",
+};
+// Audio sample rate in Hz.
+export const AudioSampleRate = {
+    _22050: 22050,
+    _44100: 44100,
+    _48000: 48000,
+};
+// PDF optimization profile. Web = aggressive; Print = preserve quality; Archive = PDF/A; Max = smallest.
+export const PdfProfile = {
+    Web: "web",
+    Print: "print",
+    Archive: "archive",
+    Max: "max",
+};
+// PDF output color space.
+export const PdfColorspace = {
+    Unchanged: "unchanged",
+    Rgb: "rgb",
+    Cmyk: "cmyk",
+    Grayscale: "grayscale",
+};
+/** Catalog of every ergonomic enum (canonicalName → wire). */
+export const ERGONOMIC_ENUMS = {
+    OptimizeFor,
+    ImageMode,
+    ImageFormat,
+    ImageFit,
+    ImageMetadataPolicy,
+    IccProfilePolicy,
+    VideoCodec,
+    VideoPreset,
+    VideoFit,
+    AudioBitrate,
+    AudioCodec,
+    AudioSampleRate,
+    PdfProfile,
+    PdfColorspace,
+};

package/dist/generated/sdk_spec/errors.d.ts

@@ -0,0 +1,16 @@
+export type ErrorCode = "missing_credentials" | "feature_requires_auth" | "undeclared_asset" | "unused_asset" | "per_input_options_not_supported" | "chain_cardinality_mismatch" | "multipart_part_invalid" | "multipart_part_count_exceeded" | "timeout" | "aborted" | "validation_failed" | "auth_failed" | "feature_tier_restricted" | "tier_restriction" | "multipart_session_ownership" | "multipart_session_auth_required" | "multipart_session_not_found" | "workflow_expired" | "balance_exhausted" | "feature_not_available" | "upload_size_exceeds_tier" | "upload_duration_exceeds_tier" | "probe_pending" | "requires_reencode" | "invalid_options" | "invalid_combination" | "missing_dependency" | "unsupported_value" | "type_mismatch" | "upload_failed" | "workflow_failed";
+export type ErrorCategory = 'api' | 'config' | 'network' | 'auth' | 'validation' | 'chain';
+export type ErrorStatus = 'wired' | 'planned';
+export interface ErrorEntry {
+    readonly code: ErrorCode;
+    readonly category: ErrorCategory;
+    readonly source: string;
+    readonly status: ErrorStatus;
+    readonly httpStatus: number | null;
+    readonly retryable: boolean;
+    readonly sdkClass: string;
+    readonly description: string;
+    readonly metadataSchema: Readonly<Record<string, string>>;
+}
+export declare const ERROR_CODES: Readonly<Record<ErrorCode, ErrorEntry>>;
+export declare const ERROR_CATEGORIES: Readonly<Record<ErrorCategory, readonly ErrorCode[]>>;