@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/lambda.d.ts

@@ -2083,7 +2083,7 @@ export declare const DeleteProvisionedConcurrencyConfigRequest: S.Schema<DeleteP
 export interface DeleteProvisionedConcurrencyConfigResponse {
 }
 export declare const DeleteProvisionedConcurrencyConfigResponse: S.Schema<DeleteProvisionedConcurrencyConfigResponse>;
-declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
+declare const InvalidParameterValueException_base: S.Class<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2093,7 +2093,7 @@ declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameter
 });
 export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
 }
-declare const ServiceException_base: S.ErrorClass<ServiceException, S.TaggedStruct<"ServiceException", {
+declare const ServiceException_base: S.Class<ServiceException, S.TaggedStruct<"ServiceException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2103,7 +2103,7 @@ declare const ServiceException_base: S.ErrorClass<ServiceException, S.TaggedStru
 });
 export declare class ServiceException extends ServiceException_base {
 }
-declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
+declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
     readonly retryAfterSeconds: S.optional<S.String>;
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -2115,7 +2115,7 @@ declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsExcepti
 });
 export declare class TooManyRequestsException extends TooManyRequestsException_base {
 }
-declare const ResourceConflictException_base: S.ErrorClass<ResourceConflictException, S.TaggedStruct<"ResourceConflictException", {
+declare const ResourceConflictException_base: S.Class<ResourceConflictException, S.TaggedStruct<"ResourceConflictException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2125,7 +2125,7 @@ declare const ResourceConflictException_base: S.ErrorClass<ResourceConflictExcep
 });
 export declare class ResourceConflictException extends ResourceConflictException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2135,17 +2135,17 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const RequestLimitExceeded_base: S.ErrorClass<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class RequestLimitExceeded extends RequestLimitExceeded_base {
 }
-declare const ParseError_base: S.ErrorClass<ParseError, S.TaggedStruct<"ParseError", {}>, import("effect/Cause").YieldableError>;
+declare const ParseError_base: S.Class<ParseError, S.TaggedStruct<"ParseError", {}>, import("effect/Cause").YieldableError>;
 export declare class ParseError extends ParseError_base {
 }
-declare const CallbackTimeoutException_base: S.ErrorClass<CallbackTimeoutException, S.TaggedStruct<"CallbackTimeoutException", {
+declare const CallbackTimeoutException_base: S.Class<CallbackTimeoutException, S.TaggedStruct<"CallbackTimeoutException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2155,7 +2155,7 @@ declare const CallbackTimeoutException_base: S.ErrorClass<CallbackTimeoutExcepti
 });
 export declare class CallbackTimeoutException extends CallbackTimeoutException_base {
 }
-declare const CapacityProviderLimitExceededException_base: S.ErrorClass<CapacityProviderLimitExceededException, S.TaggedStruct<"CapacityProviderLimitExceededException", {
+declare const CapacityProviderLimitExceededException_base: S.Class<CapacityProviderLimitExceededException, S.TaggedStruct<"CapacityProviderLimitExceededException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2165,10 +2165,10 @@ declare const CapacityProviderLimitExceededException_base: S.ErrorClass<Capacity
 });
 export declare class CapacityProviderLimitExceededException extends CapacityProviderLimitExceededException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {}>, import("effect/Cause").YieldableError>;
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {}>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const CodeSigningConfigNotFoundException_base: S.ErrorClass<CodeSigningConfigNotFoundException, S.TaggedStruct<"CodeSigningConfigNotFoundException", {
+declare const CodeSigningConfigNotFoundException_base: S.Class<CodeSigningConfigNotFoundException, S.TaggedStruct<"CodeSigningConfigNotFoundException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2178,7 +2178,7 @@ declare const CodeSigningConfigNotFoundException_base: S.ErrorClass<CodeSigningC
 });
 export declare class CodeSigningConfigNotFoundException extends CodeSigningConfigNotFoundException_base {
 }
-declare const CodeStorageExceededException_base: S.ErrorClass<CodeStorageExceededException, S.TaggedStruct<"CodeStorageExceededException", {
+declare const CodeStorageExceededException_base: S.Class<CodeStorageExceededException, S.TaggedStruct<"CodeStorageExceededException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2188,7 +2188,7 @@ declare const CodeStorageExceededException_base: S.ErrorClass<CodeStorageExceede
 });
 export declare class CodeStorageExceededException extends CodeStorageExceededException_base {
 }
-declare const CodeVerificationFailedException_base: S.ErrorClass<CodeVerificationFailedException, S.TaggedStruct<"CodeVerificationFailedException", {
+declare const CodeVerificationFailedException_base: S.Class<CodeVerificationFailedException, S.TaggedStruct<"CodeVerificationFailedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2198,7 +2198,7 @@ declare const CodeVerificationFailedException_base: S.ErrorClass<CodeVerificatio
 });
 export declare class CodeVerificationFailedException extends CodeVerificationFailedException_base {
 }
-declare const FunctionVersionsPerCapacityProviderLimitExceededException_base: S.ErrorClass<FunctionVersionsPerCapacityProviderLimitExceededException, S.TaggedStruct<"FunctionVersionsPerCapacityProviderLimitExceededException", {
+declare const FunctionVersionsPerCapacityProviderLimitExceededException_base: S.Class<FunctionVersionsPerCapacityProviderLimitExceededException, S.TaggedStruct<"FunctionVersionsPerCapacityProviderLimitExceededException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2208,7 +2208,7 @@ declare const FunctionVersionsPerCapacityProviderLimitExceededException_base: S.
 });
 export declare class FunctionVersionsPerCapacityProviderLimitExceededException extends FunctionVersionsPerCapacityProviderLimitExceededException_base {
 }
-declare const InvalidCodeSignatureException_base: S.ErrorClass<InvalidCodeSignatureException, S.TaggedStruct<"InvalidCodeSignatureException", {
+declare const InvalidCodeSignatureException_base: S.Class<InvalidCodeSignatureException, S.TaggedStruct<"InvalidCodeSignatureException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2218,13 +2218,13 @@ declare const InvalidCodeSignatureException_base: S.ErrorClass<InvalidCodeSignat
 });
 export declare class InvalidCodeSignatureException extends InvalidCodeSignatureException_base {
 }
-declare const PreconditionFailedException_base: S.ErrorClass<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
+declare const PreconditionFailedException_base: S.Class<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PreconditionFailedException extends PreconditionFailedException_base {
 }
-declare const DurableExecutionAlreadyStartedException_base: S.ErrorClass<DurableExecutionAlreadyStartedException, S.TaggedStruct<"DurableExecutionAlreadyStartedException", {
+declare const DurableExecutionAlreadyStartedException_base: S.Class<DurableExecutionAlreadyStartedException, S.TaggedStruct<"DurableExecutionAlreadyStartedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2234,7 +2234,7 @@ declare const DurableExecutionAlreadyStartedException_base: S.ErrorClass<Durable
 });
 export declare class DurableExecutionAlreadyStartedException extends DurableExecutionAlreadyStartedException_base {
 }
-declare const EC2AccessDeniedException_base: S.ErrorClass<EC2AccessDeniedException, S.TaggedStruct<"EC2AccessDeniedException", {
+declare const EC2AccessDeniedException_base: S.Class<EC2AccessDeniedException, S.TaggedStruct<"EC2AccessDeniedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2248,7 +2248,7 @@ declare const EC2AccessDeniedException_base: S.ErrorClass<EC2AccessDeniedExcepti
 });
 export declare class EC2AccessDeniedException extends EC2AccessDeniedException_base {
 }
-declare const EC2ThrottledException_base: S.ErrorClass<EC2ThrottledException, S.TaggedStruct<"EC2ThrottledException", {
+declare const EC2ThrottledException_base: S.Class<EC2ThrottledException, S.TaggedStruct<"EC2ThrottledException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2258,7 +2258,7 @@ declare const EC2ThrottledException_base: S.ErrorClass<EC2ThrottledException, S.
 });
 export declare class EC2ThrottledException extends EC2ThrottledException_base {
 }
-declare const EC2UnexpectedException_base: S.ErrorClass<EC2UnexpectedException, S.TaggedStruct<"EC2UnexpectedException", {
+declare const EC2UnexpectedException_base: S.Class<EC2UnexpectedException, S.TaggedStruct<"EC2UnexpectedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
     readonly EC2ErrorCode: S.optional<S.String>;
@@ -2269,7 +2269,7 @@ declare const EC2UnexpectedException_base: S.ErrorClass<EC2UnexpectedException,
 });
 export declare class EC2UnexpectedException extends EC2UnexpectedException_base {
 }
-declare const EFSIOException_base: S.ErrorClass<EFSIOException, S.TaggedStruct<"EFSIOException", {
+declare const EFSIOException_base: S.Class<EFSIOException, S.TaggedStruct<"EFSIOException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2279,7 +2279,7 @@ declare const EFSIOException_base: S.ErrorClass<EFSIOException, S.TaggedStruct<"
 });
 export declare class EFSIOException extends EFSIOException_base {
 }
-declare const EFSMountConnectivityException_base: S.ErrorClass<EFSMountConnectivityException, S.TaggedStruct<"EFSMountConnectivityException", {
+declare const EFSMountConnectivityException_base: S.Class<EFSMountConnectivityException, S.TaggedStruct<"EFSMountConnectivityException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2289,7 +2289,7 @@ declare const EFSMountConnectivityException_base: S.ErrorClass<EFSMountConnectiv
 });
 export declare class EFSMountConnectivityException extends EFSMountConnectivityException_base {
 }
-declare const EFSMountFailureException_base: S.ErrorClass<EFSMountFailureException, S.TaggedStruct<"EFSMountFailureException", {
+declare const EFSMountFailureException_base: S.Class<EFSMountFailureException, S.TaggedStruct<"EFSMountFailureException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2299,7 +2299,7 @@ declare const EFSMountFailureException_base: S.ErrorClass<EFSMountFailureExcepti
 });
 export declare class EFSMountFailureException extends EFSMountFailureException_base {
 }
-declare const EFSMountTimeoutException_base: S.ErrorClass<EFSMountTimeoutException, S.TaggedStruct<"EFSMountTimeoutException", {
+declare const EFSMountTimeoutException_base: S.Class<EFSMountTimeoutException, S.TaggedStruct<"EFSMountTimeoutException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2309,7 +2309,7 @@ declare const EFSMountTimeoutException_base: S.ErrorClass<EFSMountTimeoutExcepti
 });
 export declare class EFSMountTimeoutException extends EFSMountTimeoutException_base {
 }
-declare const ENILimitReachedException_base: S.ErrorClass<ENILimitReachedException, S.TaggedStruct<"ENILimitReachedException", {
+declare const ENILimitReachedException_base: S.Class<ENILimitReachedException, S.TaggedStruct<"ENILimitReachedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2319,7 +2319,7 @@ declare const ENILimitReachedException_base: S.ErrorClass<ENILimitReachedExcepti
 });
 export declare class ENILimitReachedException extends ENILimitReachedException_base {
 }
-declare const InvalidRequestContentException_base: S.ErrorClass<InvalidRequestContentException, S.TaggedStruct<"InvalidRequestContentException", {
+declare const InvalidRequestContentException_base: S.Class<InvalidRequestContentException, S.TaggedStruct<"InvalidRequestContentException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2329,7 +2329,7 @@ declare const InvalidRequestContentException_base: S.ErrorClass<InvalidRequestCo
 });
 export declare class InvalidRequestContentException extends InvalidRequestContentException_base {
 }
-declare const InvalidRuntimeException_base: S.ErrorClass<InvalidRuntimeException, S.TaggedStruct<"InvalidRuntimeException", {
+declare const InvalidRuntimeException_base: S.Class<InvalidRuntimeException, S.TaggedStruct<"InvalidRuntimeException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2339,7 +2339,7 @@ declare const InvalidRuntimeException_base: S.ErrorClass<InvalidRuntimeException
 });
 export declare class InvalidRuntimeException extends InvalidRuntimeException_base {
 }
-declare const InvalidSecurityGroupIDException_base: S.ErrorClass<InvalidSecurityGroupIDException, S.TaggedStruct<"InvalidSecurityGroupIDException", {
+declare const InvalidSecurityGroupIDException_base: S.Class<InvalidSecurityGroupIDException, S.TaggedStruct<"InvalidSecurityGroupIDException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2349,7 +2349,7 @@ declare const InvalidSecurityGroupIDException_base: S.ErrorClass<InvalidSecurity
 });
 export declare class InvalidSecurityGroupIDException extends InvalidSecurityGroupIDException_base {
 }
-declare const InvalidSubnetIDException_base: S.ErrorClass<InvalidSubnetIDException, S.TaggedStruct<"InvalidSubnetIDException", {
+declare const InvalidSubnetIDException_base: S.Class<InvalidSubnetIDException, S.TaggedStruct<"InvalidSubnetIDException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2359,7 +2359,7 @@ declare const InvalidSubnetIDException_base: S.ErrorClass<InvalidSubnetIDExcepti
 });
 export declare class InvalidSubnetIDException extends InvalidSubnetIDException_base {
 }
-declare const InvalidZipFileException_base: S.ErrorClass<InvalidZipFileException, S.TaggedStruct<"InvalidZipFileException", {
+declare const InvalidZipFileException_base: S.Class<InvalidZipFileException, S.TaggedStruct<"InvalidZipFileException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2369,7 +2369,7 @@ declare const InvalidZipFileException_base: S.ErrorClass<InvalidZipFileException
 });
 export declare class InvalidZipFileException extends InvalidZipFileException_base {
 }
-declare const KMSAccessDeniedException_base: S.ErrorClass<KMSAccessDeniedException, S.TaggedStruct<"KMSAccessDeniedException", {
+declare const KMSAccessDeniedException_base: S.Class<KMSAccessDeniedException, S.TaggedStruct<"KMSAccessDeniedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2383,7 +2383,7 @@ declare const KMSAccessDeniedException_base: S.ErrorClass<KMSAccessDeniedExcepti
 });
 export declare class KMSAccessDeniedException extends KMSAccessDeniedException_base {
 }
-declare const KMSDisabledException_base: S.ErrorClass<KMSDisabledException, S.TaggedStruct<"KMSDisabledException", {
+declare const KMSDisabledException_base: S.Class<KMSDisabledException, S.TaggedStruct<"KMSDisabledException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2393,7 +2393,7 @@ declare const KMSDisabledException_base: S.ErrorClass<KMSDisabledException, S.Ta
 });
 export declare class KMSDisabledException extends KMSDisabledException_base {
 }
-declare const KMSInvalidStateException_base: S.ErrorClass<KMSInvalidStateException, S.TaggedStruct<"KMSInvalidStateException", {
+declare const KMSInvalidStateException_base: S.Class<KMSInvalidStateException, S.TaggedStruct<"KMSInvalidStateException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2403,7 +2403,7 @@ declare const KMSInvalidStateException_base: S.ErrorClass<KMSInvalidStateExcepti
 });
 export declare class KMSInvalidStateException extends KMSInvalidStateException_base {
 }
-declare const KMSNotFoundException_base: S.ErrorClass<KMSNotFoundException, S.TaggedStruct<"KMSNotFoundException", {
+declare const KMSNotFoundException_base: S.Class<KMSNotFoundException, S.TaggedStruct<"KMSNotFoundException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2413,7 +2413,7 @@ declare const KMSNotFoundException_base: S.ErrorClass<KMSNotFoundException, S.Ta
 });
 export declare class KMSNotFoundException extends KMSNotFoundException_base {
 }
-declare const NoPublishedVersionException_base: S.ErrorClass<NoPublishedVersionException, S.TaggedStruct<"NoPublishedVersionException", {
+declare const NoPublishedVersionException_base: S.Class<NoPublishedVersionException, S.TaggedStruct<"NoPublishedVersionException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2423,7 +2423,7 @@ declare const NoPublishedVersionException_base: S.ErrorClass<NoPublishedVersionE
 });
 export declare class NoPublishedVersionException extends NoPublishedVersionException_base {
 }
-declare const RecursiveInvocationException_base: S.ErrorClass<RecursiveInvocationException, S.TaggedStruct<"RecursiveInvocationException", {
+declare const RecursiveInvocationException_base: S.Class<RecursiveInvocationException, S.TaggedStruct<"RecursiveInvocationException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2433,7 +2433,7 @@ declare const RecursiveInvocationException_base: S.ErrorClass<RecursiveInvocatio
 });
 export declare class RecursiveInvocationException extends RecursiveInvocationException_base {
 }
-declare const RequestTooLargeException_base: S.ErrorClass<RequestTooLargeException, S.TaggedStruct<"RequestTooLargeException", {
+declare const RequestTooLargeException_base: S.Class<RequestTooLargeException, S.TaggedStruct<"RequestTooLargeException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2443,7 +2443,7 @@ declare const RequestTooLargeException_base: S.ErrorClass<RequestTooLargeExcepti
 });
 export declare class RequestTooLargeException extends RequestTooLargeException_base {
 }
-declare const ResourceNotReadyException_base: S.ErrorClass<ResourceNotReadyException, S.TaggedStruct<"ResourceNotReadyException", {
+declare const ResourceNotReadyException_base: S.Class<ResourceNotReadyException, S.TaggedStruct<"ResourceNotReadyException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2453,7 +2453,7 @@ declare const ResourceNotReadyException_base: S.ErrorClass<ResourceNotReadyExcep
 });
 export declare class ResourceNotReadyException extends ResourceNotReadyException_base {
 }
-declare const SerializedRequestEntityTooLargeException_base: S.ErrorClass<SerializedRequestEntityTooLargeException, S.TaggedStruct<"SerializedRequestEntityTooLargeException", {
+declare const SerializedRequestEntityTooLargeException_base: S.Class<SerializedRequestEntityTooLargeException, S.TaggedStruct<"SerializedRequestEntityTooLargeException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2463,7 +2463,7 @@ declare const SerializedRequestEntityTooLargeException_base: S.ErrorClass<Serial
 });
 export declare class SerializedRequestEntityTooLargeException extends SerializedRequestEntityTooLargeException_base {
 }
-declare const SnapStartException_base: S.ErrorClass<SnapStartException, S.TaggedStruct<"SnapStartException", {
+declare const SnapStartException_base: S.Class<SnapStartException, S.TaggedStruct<"SnapStartException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2473,7 +2473,7 @@ declare const SnapStartException_base: S.ErrorClass<SnapStartException, S.Tagged
 });
 export declare class SnapStartException extends SnapStartException_base {
 }
-declare const SnapStartNotReadyException_base: S.ErrorClass<SnapStartNotReadyException, S.TaggedStruct<"SnapStartNotReadyException", {
+declare const SnapStartNotReadyException_base: S.Class<SnapStartNotReadyException, S.TaggedStruct<"SnapStartNotReadyException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2483,7 +2483,7 @@ declare const SnapStartNotReadyException_base: S.ErrorClass<SnapStartNotReadyExc
 });
 export declare class SnapStartNotReadyException extends SnapStartNotReadyException_base {
 }
-declare const SnapStartTimeoutException_base: S.ErrorClass<SnapStartTimeoutException, S.TaggedStruct<"SnapStartTimeoutException", {
+declare const SnapStartTimeoutException_base: S.Class<SnapStartTimeoutException, S.TaggedStruct<"SnapStartTimeoutException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2493,7 +2493,7 @@ declare const SnapStartTimeoutException_base: S.ErrorClass<SnapStartTimeoutExcep
 });
 export declare class SnapStartTimeoutException extends SnapStartTimeoutException_base {
 }
-declare const SubnetIPAddressLimitReachedException_base: S.ErrorClass<SubnetIPAddressLimitReachedException, S.TaggedStruct<"SubnetIPAddressLimitReachedException", {
+declare const SubnetIPAddressLimitReachedException_base: S.Class<SubnetIPAddressLimitReachedException, S.TaggedStruct<"SubnetIPAddressLimitReachedException", {
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2503,7 +2503,7 @@ declare const SubnetIPAddressLimitReachedException_base: S.ErrorClass<SubnetIPAd
 });
 export declare class SubnetIPAddressLimitReachedException extends SubnetIPAddressLimitReachedException_base {
 }
-declare const UnsupportedMediaTypeException_base: S.ErrorClass<UnsupportedMediaTypeException, S.TaggedStruct<"UnsupportedMediaTypeException", {
+declare const UnsupportedMediaTypeException_base: S.Class<UnsupportedMediaTypeException, S.TaggedStruct<"UnsupportedMediaTypeException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2513,7 +2513,7 @@ declare const UnsupportedMediaTypeException_base: S.ErrorClass<UnsupportedMediaT
 });
 export declare class UnsupportedMediaTypeException extends UnsupportedMediaTypeException_base {
 }
-declare const PolicyLengthExceededException_base: S.ErrorClass<PolicyLengthExceededException, S.TaggedStruct<"PolicyLengthExceededException", {
+declare const PolicyLengthExceededException_base: S.Class<PolicyLengthExceededException, S.TaggedStruct<"PolicyLengthExceededException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -2523,7 +2523,7 @@ declare const PolicyLengthExceededException_base: S.ErrorClass<PolicyLengthExcee
 });
 export declare class PolicyLengthExceededException extends PolicyLengthExceededException_base {
 }
-declare const ProvisionedConcurrencyConfigNotFoundException_base: S.ErrorClass<ProvisionedConcurrencyConfigNotFoundException, S.TaggedStruct<"ProvisionedConcurrencyConfigNotFoundException", {
+declare const ProvisionedConcurrencyConfigNotFoundException_base: S.Class<ProvisionedConcurrencyConfigNotFoundException, S.TaggedStruct<"ProvisionedConcurrencyConfigNotFoundException", {
     readonly Type: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/launch-wizard.d.ts

@@ -336,7 +336,7 @@ export interface ListDeploymentPatternVersionsOutput {
     nextToken?: string;
 }
 export declare const ListDeploymentPatternVersionsOutput: S.Schema<ListDeploymentPatternVersionsOutput>;
-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": {
@@ -345,7 +345,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -354,7 +354,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -363,7 +363,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ResourceLimitException_base: S.ErrorClass<ResourceLimitException, S.TaggedStruct<"ResourceLimitException", {
+declare const ResourceLimitException_base: S.Class<ResourceLimitException, S.TaggedStruct<"ResourceLimitException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/lex-model-building-service.d.ts

@@ -1025,7 +1025,7 @@ export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
 export interface UntagResourceResponse {
 }
 export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
-declare const BadRequestException_base: S.ErrorClass<BadRequestException, S.TaggedStruct<"BadRequestException", {
+declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1034,7 +1034,7 @@ declare const BadRequestException_base: S.ErrorClass<BadRequestException, S.Tagg
 });
 export declare class BadRequestException extends BadRequestException_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": {
@@ -1043,7 +1043,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InternalFailureException_base: S.ErrorClass<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
+declare const InternalFailureException_base: S.Class<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1052,7 +1052,7 @@ declare const InternalFailureException_base: S.ErrorClass<InternalFailureExcepti
 });
 export declare class InternalFailureException extends InternalFailureException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly retryAfterSeconds: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1062,7 +1062,7 @@ declare const LimitExceededException_base: S.ErrorClass<LimitExceededException,
 });
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedStruct<"NotFoundException", {
+declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1071,12 +1071,12 @@ declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedSt
 });
 export declare class NotFoundException extends NotFoundException_base {
 }
-declare const PreconditionFailedException_base: S.ErrorClass<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
+declare const PreconditionFailedException_base: S.Class<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PreconditionFailedException extends PreconditionFailedException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly referenceType: S.optional<S.String>;
     readonly exampleReference: S.optional<S.Schema<ResourceReference>>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1086,7 +1086,7 @@ declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException,
 });
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/lex-models-v2.d.ts

@@ -4001,7 +4001,7 @@ export interface UpdateTestSetResponse {
     lastUpdatedDateTime?: Date;
 }
 export declare const UpdateTestSetResponse: S.Schema<UpdateTestSetResponse>;
-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": {
@@ -4010,7 +4010,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4019,7 +4019,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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4028,7 +4028,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly retryAfterSeconds: S.optional<S.Number>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -4038,7 +4038,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4047,7 +4047,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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": {
@@ -4056,7 +4056,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const PreconditionFailedException_base: S.ErrorClass<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
+declare const PreconditionFailedException_base: S.Class<PreconditionFailedException, S.TaggedStruct<"PreconditionFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PreconditionFailedException extends PreconditionFailedException_base {