@distilled.cloud/aws 0.16.8 → 0.17.0

package/lib/services/dynamodb.d.ts

@@ -2122,7 +2122,15 @@ export interface UpdateTimeToLiveOutput {
 export declare const UpdateTimeToLiveOutput: S.Schema<UpdateTimeToLiveOutput>;
 declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ServerError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class InternalServerError extends InternalServerError_base {
 }
 declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {
@@ -2132,6 +2140,10 @@ declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedS
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
 });
 export declare class RequestLimitExceeded extends RequestLimitExceeded_base {
 }
@@ -2142,28 +2154,56 @@ declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStr
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ThrottlingError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
 declare const InvalidEndpointException_base: S.Class<InvalidEndpointException, S.TaggedStruct<"InvalidEndpointException", {
     readonly Message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class InvalidEndpointException extends InvalidEndpointException_base {
 }
 declare const ProvisionedThroughputExceededException_base: S.Class<ProvisionedThroughputExceededException, S.TaggedStruct<"ProvisionedThroughputExceededException", {
     readonly message: S.optional<S.String>;
     readonly ThrottlingReasons: S.optional<S.$Array<S.Schema<ThrottlingReason>>>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ThrottlingError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class ProvisionedThroughputExceededException extends ProvisionedThroughputExceededException_base {
 }
 declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
 declare const ItemCollectionSizeLimitExceededException_base: S.Class<ItemCollectionSizeLimitExceededException, S.TaggedStruct<"ItemCollectionSizeLimitExceededException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
 export declare class ItemCollectionSizeLimitExceededException extends ItemCollectionSizeLimitExceededException_base {
 }
 declare const ReplicatedWriteConflictException_base: S.Class<ReplicatedWriteConflictException, S.TaggedStruct<"ReplicatedWriteConflictException", {
@@ -2177,32 +2217,68 @@ export declare class ReplicatedWriteConflictException extends ReplicatedWriteCon
 }
 declare const BackupInUseException_base: S.Class<BackupInUseException, S.TaggedStruct<"BackupInUseException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class BackupInUseException extends BackupInUseException_base {
 }
 declare const ContinuousBackupsUnavailableException_base: S.Class<ContinuousBackupsUnavailableException, S.TaggedStruct<"ContinuousBackupsUnavailableException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class ContinuousBackupsUnavailableException extends ContinuousBackupsUnavailableException_base {
 }
 declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class LimitExceededException extends LimitExceededException_base {
 }
 declare const TableInUseException_base: S.Class<TableInUseException, S.TaggedStruct<"TableInUseException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class TableInUseException extends TableInUseException_base {
 }
 declare const TableNotFoundException_base: S.Class<TableNotFoundException, S.TaggedStruct<"TableNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class TableNotFoundException extends TableNotFoundException_base {
 }
 declare const GlobalTableAlreadyExistsException_base: S.Class<GlobalTableAlreadyExistsException, S.TaggedStruct<"GlobalTableAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
@@ -2211,53 +2287,101 @@ export declare class GlobalTableAlreadyExistsException extends GlobalTableAlread
 }
 declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
 declare const BackupNotFoundException_base: S.Class<BackupNotFoundException, S.TaggedStruct<"BackupNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class BackupNotFoundException extends BackupNotFoundException_base {
 }
 declare const ConditionalCheckFailedException_base: S.Class<ConditionalCheckFailedException, S.TaggedStruct<"ConditionalCheckFailedException", {
     readonly message: S.optional<S.String>;
     readonly Item: S.optional<S.$Record<S.String, S.optional<S.suspend<S.Schema<AttributeValue>>>>>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class ConditionalCheckFailedException extends ConditionalCheckFailedException_base {
 }
 declare const TransactionConflictException_base: S.Class<TransactionConflictException, S.TaggedStruct<"TransactionConflictException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class TransactionConflictException extends TransactionConflictException_base {
 }
 declare const PolicyNotFoundException_base: S.Class<PolicyNotFoundException, S.TaggedStruct<"PolicyNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class PolicyNotFoundException extends PolicyNotFoundException_base {
 }
 declare const ExportNotFoundException_base: S.Class<ExportNotFoundException, S.TaggedStruct<"ExportNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ExportNotFoundException extends ExportNotFoundException_base {
 }
 declare const GlobalTableNotFoundException_base: S.Class<GlobalTableNotFoundException, S.TaggedStruct<"GlobalTableNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class GlobalTableNotFoundException extends GlobalTableNotFoundException_base {
 }
 declare const ImportNotFoundException_base: S.Class<ImportNotFoundException, S.TaggedStruct<"ImportNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ImportNotFoundException extends ImportNotFoundException_base {
 }
 declare const DuplicateItemException_base: S.Class<DuplicateItemException, S.TaggedStruct<"DuplicateItemException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class DuplicateItemException extends DuplicateItemException_base {
 }
 declare const IdempotentParameterMismatchException_base: S.Class<IdempotentParameterMismatchException, S.TaggedStruct<"IdempotentParameterMismatchException", {
     readonly Message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class IdempotentParameterMismatchException extends IdempotentParameterMismatchException_base {
 }
 declare const TransactionCanceledException_base: S.Class<TransactionCanceledException, S.TaggedStruct<"TransactionCanceledException", {
@@ -2268,32 +2392,60 @@ export declare class TransactionCanceledException extends TransactionCanceledExc
 }
 declare const TransactionInProgressException_base: S.Class<TransactionInProgressException, S.TaggedStruct<"TransactionInProgressException", {
     readonly Message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class TransactionInProgressException extends TransactionInProgressException_base {
 }
 declare const ExportConflictException_base: S.Class<ExportConflictException, S.TaggedStruct<"ExportConflictException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class ExportConflictException extends ExportConflictException_base {
 }
 declare const InvalidExportTimeException_base: S.Class<InvalidExportTimeException, S.TaggedStruct<"InvalidExportTimeException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class InvalidExportTimeException extends InvalidExportTimeException_base {
 }
 declare const PointInTimeRecoveryUnavailableException_base: S.Class<PointInTimeRecoveryUnavailableException, S.TaggedStruct<"PointInTimeRecoveryUnavailableException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class PointInTimeRecoveryUnavailableException extends PointInTimeRecoveryUnavailableException_base {
 }
 declare const ImportConflictException_base: S.Class<ImportConflictException, S.TaggedStruct<"ImportConflictException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class ImportConflictException extends ImportConflictException_base {
 }
 declare const TableAlreadyExistsException_base: S.Class<TableAlreadyExistsException, S.TaggedStruct<"TableAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
@@ -2302,12 +2454,20 @@ export declare class TableAlreadyExistsException extends TableAlreadyExistsExcep
 }
 declare const InvalidRestoreTimeException_base: S.Class<InvalidRestoreTimeException, S.TaggedStruct<"InvalidRestoreTimeException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class InvalidRestoreTimeException extends InvalidRestoreTimeException_base {
 }
 declare const ReplicaAlreadyExistsException_base: S.Class<ReplicaAlreadyExistsException, S.TaggedStruct<"ReplicaAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
@@ -2316,12 +2476,20 @@ export declare class ReplicaAlreadyExistsException extends ReplicaAlreadyExistsE
 }
 declare const ReplicaNotFoundException_base: S.Class<ReplicaNotFoundException, S.TaggedStruct<"ReplicaNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ReplicaNotFoundException extends ReplicaNotFoundException_base {
 }
 declare const IndexNotFoundException_base: S.Class<IndexNotFoundException, S.TaggedStruct<"IndexNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class IndexNotFoundException extends IndexNotFoundException_base {
 }
 export type BatchExecuteStatementError = InternalServerError | RequestLimitExceeded | ThrottlingException | CommonErrors;