@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/glacier.d.ts

@@ -559,7 +559,7 @@ export interface UploadMultipartPartOutput {
     checksum?: string;
 }
 export declare const UploadMultipartPartOutput: S.Schema<UploadMultipartPartOutput>;
-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 code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -570,7 +570,7 @@ declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameter
 });
 export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
 }
-declare const MissingParameterValueException_base: S.ErrorClass<MissingParameterValueException, S.TaggedStruct<"MissingParameterValueException", {
+declare const MissingParameterValueException_base: S.Class<MissingParameterValueException, S.TaggedStruct<"MissingParameterValueException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -581,7 +581,7 @@ declare const MissingParameterValueException_base: S.ErrorClass<MissingParameter
 });
 export declare class MissingParameterValueException extends MissingParameterValueException_base {
 }
-declare const NoLongerSupportedException_base: S.ErrorClass<NoLongerSupportedException, S.TaggedStruct<"NoLongerSupportedException", {
+declare const NoLongerSupportedException_base: S.Class<NoLongerSupportedException, S.TaggedStruct<"NoLongerSupportedException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -592,7 +592,7 @@ declare const NoLongerSupportedException_base: S.ErrorClass<NoLongerSupportedExc
 });
 export declare class NoLongerSupportedException extends NoLongerSupportedException_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 code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -603,7 +603,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
+declare const ServiceUnavailableException_base: S.Class<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -614,7 +614,7 @@ declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableE
 });
 export declare class ServiceUnavailableException extends ServiceUnavailableException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -625,7 +625,7 @@ declare const LimitExceededException_base: S.ErrorClass<LimitExceededException,
 });
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const InsufficientCapacityException_base: S.ErrorClass<InsufficientCapacityException, S.TaggedStruct<"InsufficientCapacityException", {
+declare const InsufficientCapacityException_base: S.Class<InsufficientCapacityException, S.TaggedStruct<"InsufficientCapacityException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -636,7 +636,7 @@ declare const InsufficientCapacityException_base: S.ErrorClass<InsufficientCapac
 });
 export declare class InsufficientCapacityException extends InsufficientCapacityException_base {
 }
-declare const PolicyEnforcedException_base: S.ErrorClass<PolicyEnforcedException, S.TaggedStruct<"PolicyEnforcedException", {
+declare const PolicyEnforcedException_base: S.Class<PolicyEnforcedException, S.TaggedStruct<"PolicyEnforcedException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;
@@ -647,7 +647,7 @@ declare const PolicyEnforcedException_base: S.ErrorClass<PolicyEnforcedException
 });
 export declare class PolicyEnforcedException extends PolicyEnforcedException_base {
 }
-declare const RequestTimeoutException_base: S.ErrorClass<RequestTimeoutException, S.TaggedStruct<"RequestTimeoutException", {
+declare const RequestTimeoutException_base: S.Class<RequestTimeoutException, S.TaggedStruct<"RequestTimeoutException", {
     readonly type: S.optional<S.String>;
     readonly code: S.optional<S.String>;
     readonly message: S.optional<S.String>;

package/lib/services/global-accelerator.d.ts

@@ -861,7 +861,7 @@ export interface WithdrawByoipCidrResponse {
     ByoipCidr?: ByoipCidr;
 }
 export declare const WithdrawByoipCidrResponse: S.Schema<WithdrawByoipCidrResponse>;
-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": {
@@ -870,7 +870,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_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": {
@@ -879,7 +879,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const EndpointAlreadyExistsException_base: S.ErrorClass<EndpointAlreadyExistsException, S.TaggedStruct<"EndpointAlreadyExistsException", {
+declare const EndpointAlreadyExistsException_base: S.Class<EndpointAlreadyExistsException, S.TaggedStruct<"EndpointAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -892,7 +892,7 @@ declare const EndpointAlreadyExistsException_base: S.ErrorClass<EndpointAlreadyE
 });
 export declare class EndpointAlreadyExistsException extends EndpointAlreadyExistsException_base {
 }
-declare const EndpointGroupNotFoundException_base: S.ErrorClass<EndpointGroupNotFoundException, S.TaggedStruct<"EndpointGroupNotFoundException", {
+declare const EndpointGroupNotFoundException_base: S.Class<EndpointGroupNotFoundException, S.TaggedStruct<"EndpointGroupNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -901,7 +901,7 @@ declare const EndpointGroupNotFoundException_base: S.ErrorClass<EndpointGroupNot
 });
 export declare class EndpointGroupNotFoundException extends EndpointGroupNotFoundException_base {
 }
-declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
+declare const InternalServiceErrorException_base: S.Class<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -910,7 +910,7 @@ declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceEr
 });
 export declare class InternalServiceErrorException extends InternalServiceErrorException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -919,7 +919,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -928,7 +928,7 @@ declare const LimitExceededException_base: S.ErrorClass<LimitExceededException,
 });
 export declare class LimitExceededException extends LimitExceededException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -937,7 +937,7 @@ declare const TransactionInProgressException_base: S.ErrorClass<TransactionInPro
 });
 export declare class TransactionInProgressException extends TransactionInProgressException_base {
 }
-declare const ByoipCidrNotFoundException_base: S.ErrorClass<ByoipCidrNotFoundException, S.TaggedStruct<"ByoipCidrNotFoundException", {
+declare const ByoipCidrNotFoundException_base: S.Class<ByoipCidrNotFoundException, S.TaggedStruct<"ByoipCidrNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -946,7 +946,7 @@ declare const ByoipCidrNotFoundException_base: S.ErrorClass<ByoipCidrNotFoundExc
 });
 export declare class ByoipCidrNotFoundException extends ByoipCidrNotFoundException_base {
 }
-declare const IncorrectCidrStateException_base: S.ErrorClass<IncorrectCidrStateException, S.TaggedStruct<"IncorrectCidrStateException", {
+declare const IncorrectCidrStateException_base: S.Class<IncorrectCidrStateException, S.TaggedStruct<"IncorrectCidrStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -955,7 +955,7 @@ declare const IncorrectCidrStateException_base: S.ErrorClass<IncorrectCidrStateE
 });
 export declare class IncorrectCidrStateException extends IncorrectCidrStateException_base {
 }
-declare const AcceleratorNotFoundException_base: S.ErrorClass<AcceleratorNotFoundException, S.TaggedStruct<"AcceleratorNotFoundException", {
+declare const AcceleratorNotFoundException_base: S.Class<AcceleratorNotFoundException, S.TaggedStruct<"AcceleratorNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -964,7 +964,7 @@ declare const AcceleratorNotFoundException_base: S.ErrorClass<AcceleratorNotFoun
 });
 export declare class AcceleratorNotFoundException extends AcceleratorNotFoundException_base {
 }
-declare const EndpointGroupAlreadyExistsException_base: S.ErrorClass<EndpointGroupAlreadyExistsException, S.TaggedStruct<"EndpointGroupAlreadyExistsException", {
+declare const EndpointGroupAlreadyExistsException_base: S.Class<EndpointGroupAlreadyExistsException, S.TaggedStruct<"EndpointGroupAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -977,7 +977,7 @@ declare const EndpointGroupAlreadyExistsException_base: S.ErrorClass<EndpointGro
 });
 export declare class EndpointGroupAlreadyExistsException extends EndpointGroupAlreadyExistsException_base {
 }
-declare const InvalidPortRangeException_base: S.ErrorClass<InvalidPortRangeException, S.TaggedStruct<"InvalidPortRangeException", {
+declare const InvalidPortRangeException_base: S.Class<InvalidPortRangeException, S.TaggedStruct<"InvalidPortRangeException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -986,7 +986,7 @@ declare const InvalidPortRangeException_base: S.ErrorClass<InvalidPortRangeExcep
 });
 export declare class InvalidPortRangeException extends InvalidPortRangeException_base {
 }
-declare const ListenerNotFoundException_base: S.ErrorClass<ListenerNotFoundException, S.TaggedStruct<"ListenerNotFoundException", {
+declare const ListenerNotFoundException_base: S.Class<ListenerNotFoundException, S.TaggedStruct<"ListenerNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -995,7 +995,7 @@ declare const ListenerNotFoundException_base: S.ErrorClass<ListenerNotFoundExcep
 });
 export declare class ListenerNotFoundException extends ListenerNotFoundException_base {
 }
-declare const AcceleratorNotDisabledException_base: S.ErrorClass<AcceleratorNotDisabledException, S.TaggedStruct<"AcceleratorNotDisabledException", {
+declare const AcceleratorNotDisabledException_base: S.Class<AcceleratorNotDisabledException, S.TaggedStruct<"AcceleratorNotDisabledException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1004,7 +1004,7 @@ declare const AcceleratorNotDisabledException_base: S.ErrorClass<AcceleratorNotD
 });
 export declare class AcceleratorNotDisabledException extends AcceleratorNotDisabledException_base {
 }
-declare const AssociatedListenerFoundException_base: S.ErrorClass<AssociatedListenerFoundException, S.TaggedStruct<"AssociatedListenerFoundException", {
+declare const AssociatedListenerFoundException_base: S.Class<AssociatedListenerFoundException, S.TaggedStruct<"AssociatedListenerFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1013,7 +1013,7 @@ declare const AssociatedListenerFoundException_base: S.ErrorClass<AssociatedList
 });
 export declare class AssociatedListenerFoundException extends AssociatedListenerFoundException_base {
 }
-declare const AttachmentNotFoundException_base: S.ErrorClass<AttachmentNotFoundException, S.TaggedStruct<"AttachmentNotFoundException", {
+declare const AttachmentNotFoundException_base: S.Class<AttachmentNotFoundException, S.TaggedStruct<"AttachmentNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1022,7 +1022,7 @@ declare const AttachmentNotFoundException_base: S.ErrorClass<AttachmentNotFoundE
 });
 export declare class AttachmentNotFoundException extends AttachmentNotFoundException_base {
 }
-declare const AssociatedEndpointGroupFoundException_base: S.ErrorClass<AssociatedEndpointGroupFoundException, S.TaggedStruct<"AssociatedEndpointGroupFoundException", {
+declare const AssociatedEndpointGroupFoundException_base: S.Class<AssociatedEndpointGroupFoundException, S.TaggedStruct<"AssociatedEndpointGroupFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1031,7 +1031,7 @@ declare const AssociatedEndpointGroupFoundException_base: S.ErrorClass<Associate
 });
 export declare class AssociatedEndpointGroupFoundException extends AssociatedEndpointGroupFoundException_base {
 }
-declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
+declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1040,7 +1040,7 @@ declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenExcep
 });
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const EndpointNotFoundException_base: S.ErrorClass<EndpointNotFoundException, S.TaggedStruct<"EndpointNotFoundException", {
+declare const EndpointNotFoundException_base: S.Class<EndpointNotFoundException, S.TaggedStruct<"EndpointNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/glue.d.ts

@@ -8002,7 +8002,7 @@ export interface UpdateWorkflowResponse {
     Name?: string;
 }
 export declare const UpdateWorkflowResponse: S.Schema<UpdateWorkflowResponse>;
-declare const AlreadyExistsException_base: S.ErrorClass<AlreadyExistsException, S.TaggedStruct<"AlreadyExistsException", {
+declare const AlreadyExistsException_base: S.Class<AlreadyExistsException, S.TaggedStruct<"AlreadyExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8011,44 +8011,44 @@ declare const AlreadyExistsException_base: S.ErrorClass<AlreadyExistsException,
 });
 export declare class AlreadyExistsException extends AlreadyExistsException_base {
 }
-declare const EntityNotFoundException_base: S.ErrorClass<EntityNotFoundException, S.TaggedStruct<"EntityNotFoundException", {
+declare const EntityNotFoundException_base: S.Class<EntityNotFoundException, S.TaggedStruct<"EntityNotFoundException", {
     readonly Message: S.optional<S.String>;
     readonly FromFederationSource: S.optional<S.Boolean>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EntityNotFoundException extends EntityNotFoundException_base {
 }
-declare const GlueEncryptionException_base: S.ErrorClass<GlueEncryptionException, S.TaggedStruct<"GlueEncryptionException", {
+declare const GlueEncryptionException_base: S.Class<GlueEncryptionException, S.TaggedStruct<"GlueEncryptionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class GlueEncryptionException extends GlueEncryptionException_base {
 }
-declare const InternalServiceException_base: S.ErrorClass<InternalServiceException, S.TaggedStruct<"InternalServiceException", {
+declare const InternalServiceException_base: S.Class<InternalServiceException, S.TaggedStruct<"InternalServiceException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServiceException extends InternalServiceException_base {
 }
-declare const InvalidInputException_base: S.ErrorClass<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
+declare const InvalidInputException_base: S.Class<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
     readonly Message: S.optional<S.String>;
     readonly FromFederationSource: S.optional<S.Boolean>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInputException extends InvalidInputException_base {
 }
-declare const OperationTimeoutException_base: S.ErrorClass<OperationTimeoutException, S.TaggedStruct<"OperationTimeoutException", {
+declare const OperationTimeoutException_base: S.Class<OperationTimeoutException, S.TaggedStruct<"OperationTimeoutException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationTimeoutException extends OperationTimeoutException_base {
 }
-declare const ResourceNumberLimitExceededException_base: S.ErrorClass<ResourceNumberLimitExceededException, S.TaggedStruct<"ResourceNumberLimitExceededException", {
+declare const ResourceNumberLimitExceededException_base: S.Class<ResourceNumberLimitExceededException, S.TaggedStruct<"ResourceNumberLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNumberLimitExceededException extends ResourceNumberLimitExceededException_base {
 }
-declare const ResourceNotReadyException_base: S.ErrorClass<ResourceNotReadyException, S.TaggedStruct<"ResourceNotReadyException", {
+declare const ResourceNotReadyException_base: S.Class<ResourceNotReadyException, S.TaggedStruct<"ResourceNotReadyException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotReadyException extends ResourceNotReadyException_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": {
@@ -8057,38 +8057,38 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const FederationSourceException_base: S.ErrorClass<FederationSourceException, S.TaggedStruct<"FederationSourceException", {
+declare const FederationSourceException_base: S.Class<FederationSourceException, S.TaggedStruct<"FederationSourceException", {
     readonly FederationSourceErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FederationSourceException extends FederationSourceException_base {
 }
-declare const FederationSourceRetryableException_base: S.ErrorClass<FederationSourceRetryableException, S.TaggedStruct<"FederationSourceRetryableException", {
+declare const FederationSourceRetryableException_base: S.Class<FederationSourceRetryableException, S.TaggedStruct<"FederationSourceRetryableException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FederationSourceRetryableException extends FederationSourceRetryableException_base {
 }
-declare const InvalidStateException_base: S.ErrorClass<InvalidStateException, S.TaggedStruct<"InvalidStateException", {
+declare const InvalidStateException_base: S.Class<InvalidStateException, S.TaggedStruct<"InvalidStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidStateException extends InvalidStateException_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>;
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const IllegalSessionStateException_base: S.ErrorClass<IllegalSessionStateException, S.TaggedStruct<"IllegalSessionStateException", {
+declare const IllegalSessionStateException_base: S.Class<IllegalSessionStateException, S.TaggedStruct<"IllegalSessionStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IllegalSessionStateException extends IllegalSessionStateException_base {
 }
-declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
+declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
 }
-declare const FederatedResourceAlreadyExistsException_base: S.ErrorClass<FederatedResourceAlreadyExistsException, S.TaggedStruct<"FederatedResourceAlreadyExistsException", {
+declare const FederatedResourceAlreadyExistsException_base: S.Class<FederatedResourceAlreadyExistsException, S.TaggedStruct<"FederatedResourceAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
     readonly AssociatedGlueResource: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -8098,27 +8098,27 @@ declare const FederatedResourceAlreadyExistsException_base: S.ErrorClass<Federat
 });
 export declare class FederatedResourceAlreadyExistsException extends FederatedResourceAlreadyExistsException_base {
 }
-declare const ColumnStatisticsTaskRunningException_base: S.ErrorClass<ColumnStatisticsTaskRunningException, S.TaggedStruct<"ColumnStatisticsTaskRunningException", {
+declare const ColumnStatisticsTaskRunningException_base: S.Class<ColumnStatisticsTaskRunningException, S.TaggedStruct<"ColumnStatisticsTaskRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ColumnStatisticsTaskRunningException extends ColumnStatisticsTaskRunningException_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 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>;
 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>;
 export declare class ConflictException extends ConflictException_base {
 }
-declare const IntegrationConflictOperationFault_base: S.ErrorClass<IntegrationConflictOperationFault, S.TaggedStruct<"IntegrationConflictOperationFault", {
+declare const IntegrationConflictOperationFault_base: S.Class<IntegrationConflictOperationFault, S.TaggedStruct<"IntegrationConflictOperationFault", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8127,7 +8127,7 @@ declare const IntegrationConflictOperationFault_base: S.ErrorClass<IntegrationCo
 });
 export declare class IntegrationConflictOperationFault extends IntegrationConflictOperationFault_base {
 }
-declare const IntegrationQuotaExceededFault_base: S.ErrorClass<IntegrationQuotaExceededFault, S.TaggedStruct<"IntegrationQuotaExceededFault", {
+declare const IntegrationQuotaExceededFault_base: S.Class<IntegrationQuotaExceededFault, S.TaggedStruct<"IntegrationQuotaExceededFault", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8136,7 +8136,7 @@ declare const IntegrationQuotaExceededFault_base: S.ErrorClass<IntegrationQuotaE
 });
 export declare class IntegrationQuotaExceededFault extends IntegrationQuotaExceededFault_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": {
@@ -8145,7 +8145,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const KMSKeyNotAccessibleFault_base: S.ErrorClass<KMSKeyNotAccessibleFault, S.TaggedStruct<"KMSKeyNotAccessibleFault", {
+declare const KMSKeyNotAccessibleFault_base: S.Class<KMSKeyNotAccessibleFault, S.TaggedStruct<"KMSKeyNotAccessibleFault", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8154,7 +8154,7 @@ declare const KMSKeyNotAccessibleFault_base: S.ErrorClass<KMSKeyNotAccessibleFau
 });
 export declare class KMSKeyNotAccessibleFault extends KMSKeyNotAccessibleFault_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": {
@@ -8163,22 +8163,22 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const OperationNotSupportedException_base: S.ErrorClass<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
+declare const OperationNotSupportedException_base: S.Class<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationNotSupportedException extends OperationNotSupportedException_base {
 }
-declare const CrawlerRunningException_base: S.ErrorClass<CrawlerRunningException, S.TaggedStruct<"CrawlerRunningException", {
+declare const CrawlerRunningException_base: S.Class<CrawlerRunningException, S.TaggedStruct<"CrawlerRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CrawlerRunningException extends CrawlerRunningException_base {
 }
-declare const SchedulerTransitioningException_base: S.ErrorClass<SchedulerTransitioningException, S.TaggedStruct<"SchedulerTransitioningException", {
+declare const SchedulerTransitioningException_base: S.Class<SchedulerTransitioningException, S.TaggedStruct<"SchedulerTransitioningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SchedulerTransitioningException extends SchedulerTransitioningException_base {
 }
-declare const IntegrationNotFoundFault_base: S.ErrorClass<IntegrationNotFoundFault, S.TaggedStruct<"IntegrationNotFoundFault", {
+declare const IntegrationNotFoundFault_base: S.Class<IntegrationNotFoundFault, S.TaggedStruct<"IntegrationNotFoundFault", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8187,7 +8187,7 @@ declare const IntegrationNotFoundFault_base: S.ErrorClass<IntegrationNotFoundFau
 });
 export declare class IntegrationNotFoundFault extends IntegrationNotFoundFault_base {
 }
-declare const InvalidIntegrationStateFault_base: S.ErrorClass<InvalidIntegrationStateFault, S.TaggedStruct<"InvalidIntegrationStateFault", {
+declare const InvalidIntegrationStateFault_base: S.Class<InvalidIntegrationStateFault, S.TaggedStruct<"InvalidIntegrationStateFault", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8196,12 +8196,12 @@ declare const InvalidIntegrationStateFault_base: S.ErrorClass<InvalidIntegration
 });
 export declare class InvalidIntegrationStateFault extends InvalidIntegrationStateFault_base {
 }
-declare const ConditionCheckFailureException_base: S.ErrorClass<ConditionCheckFailureException, S.TaggedStruct<"ConditionCheckFailureException", {
+declare const ConditionCheckFailureException_base: S.Class<ConditionCheckFailureException, S.TaggedStruct<"ConditionCheckFailureException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConditionCheckFailureException extends ConditionCheckFailureException_base {
 }
-declare const TargetResourceNotFound_base: S.ErrorClass<TargetResourceNotFound, S.TaggedStruct<"TargetResourceNotFound", {
+declare const TargetResourceNotFound_base: S.Class<TargetResourceNotFound, S.TaggedStruct<"TargetResourceNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -8210,82 +8210,82 @@ declare const TargetResourceNotFound_base: S.ErrorClass<TargetResourceNotFound,
 });
 export declare class TargetResourceNotFound extends TargetResourceNotFound_base {
 }
-declare const PermissionTypeMismatchException_base: S.ErrorClass<PermissionTypeMismatchException, S.TaggedStruct<"PermissionTypeMismatchException", {
+declare const PermissionTypeMismatchException_base: S.Class<PermissionTypeMismatchException, S.TaggedStruct<"PermissionTypeMismatchException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PermissionTypeMismatchException extends PermissionTypeMismatchException_base {
 }
-declare const ConcurrentRunsExceededException_base: S.ErrorClass<ConcurrentRunsExceededException, S.TaggedStruct<"ConcurrentRunsExceededException", {
+declare const ConcurrentRunsExceededException_base: S.Class<ConcurrentRunsExceededException, S.TaggedStruct<"ConcurrentRunsExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConcurrentRunsExceededException extends ConcurrentRunsExceededException_base {
 }
-declare const IllegalWorkflowStateException_base: S.ErrorClass<IllegalWorkflowStateException, S.TaggedStruct<"IllegalWorkflowStateException", {
+declare const IllegalWorkflowStateException_base: S.Class<IllegalWorkflowStateException, S.TaggedStruct<"IllegalWorkflowStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IllegalWorkflowStateException extends IllegalWorkflowStateException_base {
 }
-declare const IllegalBlueprintStateException_base: S.ErrorClass<IllegalBlueprintStateException, S.TaggedStruct<"IllegalBlueprintStateException", {
+declare const IllegalBlueprintStateException_base: S.Class<IllegalBlueprintStateException, S.TaggedStruct<"IllegalBlueprintStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IllegalBlueprintStateException extends IllegalBlueprintStateException_base {
 }
-declare const NoScheduleException_base: S.ErrorClass<NoScheduleException, S.TaggedStruct<"NoScheduleException", {
+declare const NoScheduleException_base: S.Class<NoScheduleException, S.TaggedStruct<"NoScheduleException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoScheduleException extends NoScheduleException_base {
 }
-declare const SchedulerRunningException_base: S.ErrorClass<SchedulerRunningException, S.TaggedStruct<"SchedulerRunningException", {
+declare const SchedulerRunningException_base: S.Class<SchedulerRunningException, S.TaggedStruct<"SchedulerRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SchedulerRunningException extends SchedulerRunningException_base {
 }
-declare const MaterializedViewRefreshTaskRunningException_base: S.ErrorClass<MaterializedViewRefreshTaskRunningException, S.TaggedStruct<"MaterializedViewRefreshTaskRunningException", {
+declare const MaterializedViewRefreshTaskRunningException_base: S.Class<MaterializedViewRefreshTaskRunningException, S.TaggedStruct<"MaterializedViewRefreshTaskRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaterializedViewRefreshTaskRunningException extends MaterializedViewRefreshTaskRunningException_base {
 }
-declare const MLTransformNotReadyException_base: S.ErrorClass<MLTransformNotReadyException, S.TaggedStruct<"MLTransformNotReadyException", {
+declare const MLTransformNotReadyException_base: S.Class<MLTransformNotReadyException, S.TaggedStruct<"MLTransformNotReadyException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MLTransformNotReadyException extends MLTransformNotReadyException_base {
 }
-declare const ColumnStatisticsTaskNotRunningException_base: S.ErrorClass<ColumnStatisticsTaskNotRunningException, S.TaggedStruct<"ColumnStatisticsTaskNotRunningException", {
+declare const ColumnStatisticsTaskNotRunningException_base: S.Class<ColumnStatisticsTaskNotRunningException, S.TaggedStruct<"ColumnStatisticsTaskNotRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ColumnStatisticsTaskNotRunningException extends ColumnStatisticsTaskNotRunningException_base {
 }
-declare const ColumnStatisticsTaskStoppingException_base: S.ErrorClass<ColumnStatisticsTaskStoppingException, S.TaggedStruct<"ColumnStatisticsTaskStoppingException", {
+declare const ColumnStatisticsTaskStoppingException_base: S.Class<ColumnStatisticsTaskStoppingException, S.TaggedStruct<"ColumnStatisticsTaskStoppingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ColumnStatisticsTaskStoppingException extends ColumnStatisticsTaskStoppingException_base {
 }
-declare const CrawlerNotRunningException_base: S.ErrorClass<CrawlerNotRunningException, S.TaggedStruct<"CrawlerNotRunningException", {
+declare const CrawlerNotRunningException_base: S.Class<CrawlerNotRunningException, S.TaggedStruct<"CrawlerNotRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CrawlerNotRunningException extends CrawlerNotRunningException_base {
 }
-declare const CrawlerStoppingException_base: S.ErrorClass<CrawlerStoppingException, S.TaggedStruct<"CrawlerStoppingException", {
+declare const CrawlerStoppingException_base: S.Class<CrawlerStoppingException, S.TaggedStruct<"CrawlerStoppingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CrawlerStoppingException extends CrawlerStoppingException_base {
 }
-declare const SchedulerNotRunningException_base: S.ErrorClass<SchedulerNotRunningException, S.TaggedStruct<"SchedulerNotRunningException", {
+declare const SchedulerNotRunningException_base: S.Class<SchedulerNotRunningException, S.TaggedStruct<"SchedulerNotRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SchedulerNotRunningException extends SchedulerNotRunningException_base {
 }
-declare const MaterializedViewRefreshTaskNotRunningException_base: S.ErrorClass<MaterializedViewRefreshTaskNotRunningException, S.TaggedStruct<"MaterializedViewRefreshTaskNotRunningException", {
+declare const MaterializedViewRefreshTaskNotRunningException_base: S.Class<MaterializedViewRefreshTaskNotRunningException, S.TaggedStruct<"MaterializedViewRefreshTaskNotRunningException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaterializedViewRefreshTaskNotRunningException extends MaterializedViewRefreshTaskNotRunningException_base {
 }
-declare const MaterializedViewRefreshTaskStoppingException_base: S.ErrorClass<MaterializedViewRefreshTaskStoppingException, S.TaggedStruct<"MaterializedViewRefreshTaskStoppingException", {
+declare const MaterializedViewRefreshTaskStoppingException_base: S.Class<MaterializedViewRefreshTaskStoppingException, S.TaggedStruct<"MaterializedViewRefreshTaskStoppingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaterializedViewRefreshTaskStoppingException extends MaterializedViewRefreshTaskStoppingException_base {
 }
-declare const VersionMismatchException_base: S.ErrorClass<VersionMismatchException, S.TaggedStruct<"VersionMismatchException", {
+declare const VersionMismatchException_base: S.Class<VersionMismatchException, S.TaggedStruct<"VersionMismatchException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class VersionMismatchException extends VersionMismatchException_base {