@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/dsql.d.ts

@@ -211,7 +211,7 @@ export interface PutClusterPolicyOutput {
     policyVersion: string;
 }
 export declare const PutClusterPolicyOutput: S.Schema<PutClusterPolicyOutput>;
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.String;
     readonly resourceId: S.String;
     readonly resourceType: S.String;
@@ -222,7 +222,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly message: S.String;
     readonly resourceId: S.String;
     readonly resourceType: S.String;
@@ -235,7 +235,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly message: S.String;
     readonly resourceId: S.optional<S.String>;
     readonly resourceType: S.optional<S.String>;
@@ -246,7 +246,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly message: S.String;
     readonly reason: S.String;
     readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
@@ -257,7 +257,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.String;
     readonly retryAfterSeconds: S.optional<S.Number>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -271,7 +271,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.String;
     readonly serviceCode: S.optional<S.String>;
     readonly quotaCode: S.optional<S.String>;

package/lib/services/dynamodb-streams.d.ts

@@ -282,27 +282,27 @@ export interface ListStreamsOutput {
     LastEvaluatedStreamArn?: string;
 }
 export declare const ListStreamsOutput: S.Schema<ListStreamsOutput>;
-declare const InternalServerError_base: S.ErrorClass<InternalServerError, S.TaggedStruct<"InternalServerError", {
+declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServerError extends InternalServerError_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ExpiredIteratorException_base: S.ErrorClass<ExpiredIteratorException, S.TaggedStruct<"ExpiredIteratorException", {
+declare const ExpiredIteratorException_base: S.Class<ExpiredIteratorException, S.TaggedStruct<"ExpiredIteratorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExpiredIteratorException extends ExpiredIteratorException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const TrimmedDataAccessException_base: S.ErrorClass<TrimmedDataAccessException, S.TaggedStruct<"TrimmedDataAccessException", {
+declare const TrimmedDataAccessException_base: S.Class<TrimmedDataAccessException, S.TaggedStruct<"TrimmedDataAccessException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TrimmedDataAccessException extends TrimmedDataAccessException_base {

package/lib/services/dynamodb.d.ts

@@ -2119,12 +2119,12 @@ export interface UpdateTimeToLiveOutput {
     TimeToLiveSpecification?: TimeToLiveSpecification;
 }
 export declare const UpdateTimeToLiveOutput: S.Schema<UpdateTimeToLiveOutput>;
-declare const InternalServerError_base: S.ErrorClass<InternalServerError, S.TaggedStruct<"InternalServerError", {
+declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServerError extends InternalServerError_base {
 }
-declare const RequestLimitExceeded_base: S.ErrorClass<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {
+declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {
     readonly message: S.optional<S.String>;
     readonly ThrottlingReasons: S.optional<S.$Array<S.Schema<ThrottlingReason>>>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2134,7 +2134,7 @@ declare const RequestLimitExceeded_base: S.ErrorClass<RequestLimitExceeded, S.Ta
 });
 export declare class RequestLimitExceeded extends RequestLimitExceeded_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.optional<S.String>;
     readonly throttlingReasons: S.optional<S.$Array<S.Schema<ThrottlingReason>>>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2144,28 +2144,28 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const InvalidEndpointException_base: S.ErrorClass<InvalidEndpointException, S.TaggedStruct<"InvalidEndpointException", {
+declare const InvalidEndpointException_base: S.Class<InvalidEndpointException, S.TaggedStruct<"InvalidEndpointException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidEndpointException extends InvalidEndpointException_base {
 }
-declare const ProvisionedThroughputExceededException_base: S.ErrorClass<ProvisionedThroughputExceededException, S.TaggedStruct<"ProvisionedThroughputExceededException", {
+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>;
 export declare class ProvisionedThroughputExceededException extends ProvisionedThroughputExceededException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ItemCollectionSizeLimitExceededException_base: S.ErrorClass<ItemCollectionSizeLimitExceededException, S.TaggedStruct<"ItemCollectionSizeLimitExceededException", {
+declare const ItemCollectionSizeLimitExceededException_base: S.Class<ItemCollectionSizeLimitExceededException, S.TaggedStruct<"ItemCollectionSizeLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ItemCollectionSizeLimitExceededException extends ItemCollectionSizeLimitExceededException_base {
 }
-declare const ReplicatedWriteConflictException_base: S.ErrorClass<ReplicatedWriteConflictException, S.TaggedStruct<"ReplicatedWriteConflictException", {
+declare const ReplicatedWriteConflictException_base: S.Class<ReplicatedWriteConflictException, S.TaggedStruct<"ReplicatedWriteConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2174,32 +2174,32 @@ declare const ReplicatedWriteConflictException_base: S.ErrorClass<ReplicatedWrit
 });
 export declare class ReplicatedWriteConflictException extends ReplicatedWriteConflictException_base {
 }
-declare const BackupInUseException_base: S.ErrorClass<BackupInUseException, S.TaggedStruct<"BackupInUseException", {
+declare const BackupInUseException_base: S.Class<BackupInUseException, S.TaggedStruct<"BackupInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupInUseException extends BackupInUseException_base {
 }
-declare const ContinuousBackupsUnavailableException_base: S.ErrorClass<ContinuousBackupsUnavailableException, S.TaggedStruct<"ContinuousBackupsUnavailableException", {
+declare const ContinuousBackupsUnavailableException_base: S.Class<ContinuousBackupsUnavailableException, S.TaggedStruct<"ContinuousBackupsUnavailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ContinuousBackupsUnavailableException extends ContinuousBackupsUnavailableException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const TableInUseException_base: S.ErrorClass<TableInUseException, S.TaggedStruct<"TableInUseException", {
+declare const TableInUseException_base: S.Class<TableInUseException, S.TaggedStruct<"TableInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TableInUseException extends TableInUseException_base {
 }
-declare const TableNotFoundException_base: S.ErrorClass<TableNotFoundException, S.TaggedStruct<"TableNotFoundException", {
+declare const TableNotFoundException_base: S.Class<TableNotFoundException, S.TaggedStruct<"TableNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TableNotFoundException extends TableNotFoundException_base {
 }
-declare const GlobalTableAlreadyExistsException_base: S.ErrorClass<GlobalTableAlreadyExistsException, S.TaggedStruct<"GlobalTableAlreadyExistsException", {
+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": {
@@ -2208,89 +2208,89 @@ declare const GlobalTableAlreadyExistsException_base: S.ErrorClass<GlobalTableAl
 });
 export declare class GlobalTableAlreadyExistsException extends GlobalTableAlreadyExistsException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const BackupNotFoundException_base: S.ErrorClass<BackupNotFoundException, S.TaggedStruct<"BackupNotFoundException", {
+declare const BackupNotFoundException_base: S.Class<BackupNotFoundException, S.TaggedStruct<"BackupNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupNotFoundException extends BackupNotFoundException_base {
 }
-declare const ConditionalCheckFailedException_base: S.ErrorClass<ConditionalCheckFailedException, S.TaggedStruct<"ConditionalCheckFailedException", {
+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>;
 export declare class ConditionalCheckFailedException extends ConditionalCheckFailedException_base {
 }
-declare const TransactionConflictException_base: S.ErrorClass<TransactionConflictException, S.TaggedStruct<"TransactionConflictException", {
+declare const TransactionConflictException_base: S.Class<TransactionConflictException, S.TaggedStruct<"TransactionConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TransactionConflictException extends TransactionConflictException_base {
 }
-declare const PolicyNotFoundException_base: S.ErrorClass<PolicyNotFoundException, S.TaggedStruct<"PolicyNotFoundException", {
+declare const PolicyNotFoundException_base: S.Class<PolicyNotFoundException, S.TaggedStruct<"PolicyNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PolicyNotFoundException extends PolicyNotFoundException_base {
 }
-declare const ExportNotFoundException_base: S.ErrorClass<ExportNotFoundException, S.TaggedStruct<"ExportNotFoundException", {
+declare const ExportNotFoundException_base: S.Class<ExportNotFoundException, S.TaggedStruct<"ExportNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExportNotFoundException extends ExportNotFoundException_base {
 }
-declare const GlobalTableNotFoundException_base: S.ErrorClass<GlobalTableNotFoundException, S.TaggedStruct<"GlobalTableNotFoundException", {
+declare const GlobalTableNotFoundException_base: S.Class<GlobalTableNotFoundException, S.TaggedStruct<"GlobalTableNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class GlobalTableNotFoundException extends GlobalTableNotFoundException_base {
 }
-declare const ImportNotFoundException_base: S.ErrorClass<ImportNotFoundException, S.TaggedStruct<"ImportNotFoundException", {
+declare const ImportNotFoundException_base: S.Class<ImportNotFoundException, S.TaggedStruct<"ImportNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ImportNotFoundException extends ImportNotFoundException_base {
 }
-declare const DuplicateItemException_base: S.ErrorClass<DuplicateItemException, S.TaggedStruct<"DuplicateItemException", {
+declare const DuplicateItemException_base: S.Class<DuplicateItemException, S.TaggedStruct<"DuplicateItemException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicateItemException extends DuplicateItemException_base {
 }
-declare const IdempotentParameterMismatchException_base: S.ErrorClass<IdempotentParameterMismatchException, S.TaggedStruct<"IdempotentParameterMismatchException", {
+declare const IdempotentParameterMismatchException_base: S.Class<IdempotentParameterMismatchException, S.TaggedStruct<"IdempotentParameterMismatchException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IdempotentParameterMismatchException extends IdempotentParameterMismatchException_base {
 }
-declare const TransactionCanceledException_base: S.ErrorClass<TransactionCanceledException, S.TaggedStruct<"TransactionCanceledException", {
+declare const TransactionCanceledException_base: S.Class<TransactionCanceledException, S.TaggedStruct<"TransactionCanceledException", {
     readonly Message: S.optional<S.String>;
     readonly CancellationReasons: S.optional<S.$Array<S.Schema<CancellationReason>>>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TransactionCanceledException extends TransactionCanceledException_base {
 }
-declare const TransactionInProgressException_base: S.ErrorClass<TransactionInProgressException, S.TaggedStruct<"TransactionInProgressException", {
+declare const TransactionInProgressException_base: S.Class<TransactionInProgressException, S.TaggedStruct<"TransactionInProgressException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TransactionInProgressException extends TransactionInProgressException_base {
 }
-declare const ExportConflictException_base: S.ErrorClass<ExportConflictException, S.TaggedStruct<"ExportConflictException", {
+declare const ExportConflictException_base: S.Class<ExportConflictException, S.TaggedStruct<"ExportConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExportConflictException extends ExportConflictException_base {
 }
-declare const InvalidExportTimeException_base: S.ErrorClass<InvalidExportTimeException, S.TaggedStruct<"InvalidExportTimeException", {
+declare const InvalidExportTimeException_base: S.Class<InvalidExportTimeException, S.TaggedStruct<"InvalidExportTimeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExportTimeException extends InvalidExportTimeException_base {
 }
-declare const PointInTimeRecoveryUnavailableException_base: S.ErrorClass<PointInTimeRecoveryUnavailableException, S.TaggedStruct<"PointInTimeRecoveryUnavailableException", {
+declare const PointInTimeRecoveryUnavailableException_base: S.Class<PointInTimeRecoveryUnavailableException, S.TaggedStruct<"PointInTimeRecoveryUnavailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PointInTimeRecoveryUnavailableException extends PointInTimeRecoveryUnavailableException_base {
 }
-declare const ImportConflictException_base: S.ErrorClass<ImportConflictException, S.TaggedStruct<"ImportConflictException", {
+declare const ImportConflictException_base: S.Class<ImportConflictException, S.TaggedStruct<"ImportConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ImportConflictException extends ImportConflictException_base {
 }
-declare const TableAlreadyExistsException_base: S.ErrorClass<TableAlreadyExistsException, S.TaggedStruct<"TableAlreadyExistsException", {
+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": {
@@ -2299,12 +2299,12 @@ declare const TableAlreadyExistsException_base: S.ErrorClass<TableAlreadyExistsE
 });
 export declare class TableAlreadyExistsException extends TableAlreadyExistsException_base {
 }
-declare const InvalidRestoreTimeException_base: S.ErrorClass<InvalidRestoreTimeException, S.TaggedStruct<"InvalidRestoreTimeException", {
+declare const InvalidRestoreTimeException_base: S.Class<InvalidRestoreTimeException, S.TaggedStruct<"InvalidRestoreTimeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRestoreTimeException extends InvalidRestoreTimeException_base {
 }
-declare const ReplicaAlreadyExistsException_base: S.ErrorClass<ReplicaAlreadyExistsException, S.TaggedStruct<"ReplicaAlreadyExistsException", {
+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": {
@@ -2313,12 +2313,12 @@ declare const ReplicaAlreadyExistsException_base: S.ErrorClass<ReplicaAlreadyExi
 });
 export declare class ReplicaAlreadyExistsException extends ReplicaAlreadyExistsException_base {
 }
-declare const ReplicaNotFoundException_base: S.ErrorClass<ReplicaNotFoundException, S.TaggedStruct<"ReplicaNotFoundException", {
+declare const ReplicaNotFoundException_base: S.Class<ReplicaNotFoundException, S.TaggedStruct<"ReplicaNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReplicaNotFoundException extends ReplicaNotFoundException_base {
 }
-declare const IndexNotFoundException_base: S.ErrorClass<IndexNotFoundException, S.TaggedStruct<"IndexNotFoundException", {
+declare const IndexNotFoundException_base: S.Class<IndexNotFoundException, S.TaggedStruct<"IndexNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IndexNotFoundException extends IndexNotFoundException_base {

package/lib/services/ebs.d.ts

@@ -162,7 +162,7 @@ export interface StartSnapshotResponse {
     SseType?: SSEType;
 }
 export declare const StartSnapshotResponse: S.Schema<StartSnapshotResponse>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -172,7 +172,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -181,7 +181,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const RequestThrottledException_base: S.ErrorClass<RequestThrottledException, S.TaggedStruct<"RequestThrottledException", {
+declare const RequestThrottledException_base: S.Class<RequestThrottledException, S.TaggedStruct<"RequestThrottledException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -191,7 +191,7 @@ declare const RequestThrottledException_base: S.ErrorClass<RequestThrottledExcep
 });
 export declare class RequestThrottledException extends RequestThrottledException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -201,7 +201,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -211,7 +211,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -221,10 +221,10 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const InvalidSignatureException_base: S.ErrorClass<InvalidSignatureException, S.TaggedStruct<"InvalidSignatureException", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSignatureException_base: S.Class<InvalidSignatureException, S.TaggedStruct<"InvalidSignatureException", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSignatureException extends InvalidSignatureException_base {
 }
-declare const ConcurrentLimitExceededException_base: S.ErrorClass<ConcurrentLimitExceededException, S.TaggedStruct<"ConcurrentLimitExceededException", {
+declare const ConcurrentLimitExceededException_base: S.Class<ConcurrentLimitExceededException, S.TaggedStruct<"ConcurrentLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -233,7 +233,7 @@ declare const ConcurrentLimitExceededException_base: S.ErrorClass<ConcurrentLimi
 });
 export declare class ConcurrentLimitExceededException extends ConcurrentLimitExceededException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/ec2-instance-connect.d.ts

@@ -34,7 +34,7 @@ export interface SendSSHPublicKeyResponse {
     Success?: boolean;
 }
 export declare const SendSSHPublicKeyResponse: S.Schema<SendSSHPublicKeyResponse>;
-declare const AuthException_base: S.ErrorClass<AuthException, S.TaggedStruct<"AuthException", {
+declare const AuthException_base: S.Class<AuthException, S.TaggedStruct<"AuthException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -43,7 +43,7 @@ declare const AuthException_base: S.ErrorClass<AuthException, S.TaggedStruct<"Au
 });
 export declare class AuthException extends AuthException_base {
 }
-declare const EC2InstanceNotFoundException_base: S.ErrorClass<EC2InstanceNotFoundException, S.TaggedStruct<"EC2InstanceNotFoundException", {
+declare const EC2InstanceNotFoundException_base: S.Class<EC2InstanceNotFoundException, S.TaggedStruct<"EC2InstanceNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -52,7 +52,7 @@ declare const EC2InstanceNotFoundException_base: S.ErrorClass<EC2InstanceNotFoun
 });
 export declare class EC2InstanceNotFoundException extends EC2InstanceNotFoundException_base {
 }
-declare const EC2InstanceStateInvalidException_base: S.ErrorClass<EC2InstanceStateInvalidException, S.TaggedStruct<"EC2InstanceStateInvalidException", {
+declare const EC2InstanceStateInvalidException_base: S.Class<EC2InstanceStateInvalidException, S.TaggedStruct<"EC2InstanceStateInvalidException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -61,7 +61,7 @@ declare const EC2InstanceStateInvalidException_base: S.ErrorClass<EC2InstanceSta
 });
 export declare class EC2InstanceStateInvalidException extends EC2InstanceStateInvalidException_base {
 }
-declare const EC2InstanceTypeInvalidException_base: S.ErrorClass<EC2InstanceTypeInvalidException, S.TaggedStruct<"EC2InstanceTypeInvalidException", {
+declare const EC2InstanceTypeInvalidException_base: S.Class<EC2InstanceTypeInvalidException, S.TaggedStruct<"EC2InstanceTypeInvalidException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -70,7 +70,7 @@ declare const EC2InstanceTypeInvalidException_base: S.ErrorClass<EC2InstanceType
 });
 export declare class EC2InstanceTypeInvalidException extends EC2InstanceTypeInvalidException_base {
 }
-declare const EC2InstanceUnavailableException_base: S.ErrorClass<EC2InstanceUnavailableException, S.TaggedStruct<"EC2InstanceUnavailableException", {
+declare const EC2InstanceUnavailableException_base: S.Class<EC2InstanceUnavailableException, S.TaggedStruct<"EC2InstanceUnavailableException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -79,7 +79,7 @@ declare const EC2InstanceUnavailableException_base: S.ErrorClass<EC2InstanceUnav
 });
 export declare class EC2InstanceUnavailableException extends EC2InstanceUnavailableException_base {
 }
-declare const InvalidArgsException_base: S.ErrorClass<InvalidArgsException, S.TaggedStruct<"InvalidArgsException", {
+declare const InvalidArgsException_base: S.Class<InvalidArgsException, S.TaggedStruct<"InvalidArgsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -88,7 +88,7 @@ declare const InvalidArgsException_base: S.ErrorClass<InvalidArgsException, S.Ta
 });
 export declare class InvalidArgsException extends InvalidArgsException_base {
 }
-declare const SerialConsoleAccessDisabledException_base: S.ErrorClass<SerialConsoleAccessDisabledException, S.TaggedStruct<"SerialConsoleAccessDisabledException", {
+declare const SerialConsoleAccessDisabledException_base: S.Class<SerialConsoleAccessDisabledException, S.TaggedStruct<"SerialConsoleAccessDisabledException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -97,7 +97,7 @@ declare const SerialConsoleAccessDisabledException_base: S.ErrorClass<SerialCons
 });
 export declare class SerialConsoleAccessDisabledException extends SerialConsoleAccessDisabledException_base {
 }
-declare const SerialConsoleSessionLimitExceededException_base: S.ErrorClass<SerialConsoleSessionLimitExceededException, S.TaggedStruct<"SerialConsoleSessionLimitExceededException", {
+declare const SerialConsoleSessionLimitExceededException_base: S.Class<SerialConsoleSessionLimitExceededException, S.TaggedStruct<"SerialConsoleSessionLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -106,7 +106,7 @@ declare const SerialConsoleSessionLimitExceededException_base: S.ErrorClass<Seri
 });
 export declare class SerialConsoleSessionLimitExceededException extends SerialConsoleSessionLimitExceededException_base {
 }
-declare const SerialConsoleSessionUnavailableException_base: S.ErrorClass<SerialConsoleSessionUnavailableException, S.TaggedStruct<"SerialConsoleSessionUnavailableException", {
+declare const SerialConsoleSessionUnavailableException_base: S.Class<SerialConsoleSessionUnavailableException, S.TaggedStruct<"SerialConsoleSessionUnavailableException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -115,7 +115,7 @@ declare const SerialConsoleSessionUnavailableException_base: S.ErrorClass<Serial
 });
 export declare class SerialConsoleSessionUnavailableException extends SerialConsoleSessionUnavailableException_base {
 }
-declare const SerialConsoleSessionUnsupportedException_base: S.ErrorClass<SerialConsoleSessionUnsupportedException, S.TaggedStruct<"SerialConsoleSessionUnsupportedException", {
+declare const SerialConsoleSessionUnsupportedException_base: S.Class<SerialConsoleSessionUnsupportedException, S.TaggedStruct<"SerialConsoleSessionUnsupportedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -124,7 +124,7 @@ declare const SerialConsoleSessionUnsupportedException_base: S.ErrorClass<Serial
 });
 export declare class SerialConsoleSessionUnsupportedException extends SerialConsoleSessionUnsupportedException_base {
 }
-declare const ServiceException_base: S.ErrorClass<ServiceException, S.TaggedStruct<"ServiceException", {
+declare const ServiceException_base: S.Class<ServiceException, S.TaggedStruct<"ServiceException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -133,7 +133,7 @@ declare const ServiceException_base: S.ErrorClass<ServiceException, S.TaggedStru
 });
 export declare class ServiceException extends ServiceException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {