@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/snow-device-management.d.ts

@@ -327,7 +327,7 @@ export interface ListExecutionsOutput {
     nextToken?: string;
 }
 export declare const ListExecutionsOutput: S.Schema<ListExecutionsOutput>;
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -340,7 +340,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -349,7 +349,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -358,7 +358,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -367,7 +367,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_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;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -380,7 +380,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_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;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/snowball.d.ts

@@ -617,54 +617,54 @@ export declare const UpdateLongTermPricingRequest: S.Schema<UpdateLongTermPricin
 export interface UpdateLongTermPricingResult {
 }
 export declare const UpdateLongTermPricingResult: S.Schema<UpdateLongTermPricingResult>;
-declare const InvalidJobStateException_base: S.ErrorClass<InvalidJobStateException, S.TaggedStruct<"InvalidJobStateException", {
+declare const InvalidJobStateException_base: S.Class<InvalidJobStateException, S.TaggedStruct<"InvalidJobStateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidJobStateException extends InvalidJobStateException_base {
 }
-declare const InvalidResourceException_base: S.ErrorClass<InvalidResourceException, S.TaggedStruct<"InvalidResourceException", {
+declare const InvalidResourceException_base: S.Class<InvalidResourceException, S.TaggedStruct<"InvalidResourceException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceType: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceException extends InvalidResourceException_base {
 }
-declare const KMSRequestFailedException_base: S.ErrorClass<KMSRequestFailedException, S.TaggedStruct<"KMSRequestFailedException", {
+declare const KMSRequestFailedException_base: S.Class<KMSRequestFailedException, S.TaggedStruct<"KMSRequestFailedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSRequestFailedException extends KMSRequestFailedException_base {
 }
-declare const InvalidAddressException_base: S.ErrorClass<InvalidAddressException, S.TaggedStruct<"InvalidAddressException", {
+declare const InvalidAddressException_base: S.Class<InvalidAddressException, S.TaggedStruct<"InvalidAddressException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAddressException extends InvalidAddressException_base {
 }
-declare const UnsupportedAddressException_base: S.ErrorClass<UnsupportedAddressException, S.TaggedStruct<"UnsupportedAddressException", {
+declare const UnsupportedAddressException_base: S.Class<UnsupportedAddressException, S.TaggedStruct<"UnsupportedAddressException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedAddressException extends UnsupportedAddressException_base {
 }
-declare const Ec2RequestFailedException_base: S.ErrorClass<Ec2RequestFailedException, S.TaggedStruct<"Ec2RequestFailedException", {
+declare const Ec2RequestFailedException_base: S.Class<Ec2RequestFailedException, S.TaggedStruct<"Ec2RequestFailedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class Ec2RequestFailedException extends Ec2RequestFailedException_base {
 }
-declare const InvalidInputCombinationException_base: S.ErrorClass<InvalidInputCombinationException, S.TaggedStruct<"InvalidInputCombinationException", {
+declare const InvalidInputCombinationException_base: S.Class<InvalidInputCombinationException, S.TaggedStruct<"InvalidInputCombinationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInputCombinationException extends InvalidInputCombinationException_base {
 }
-declare const ClusterLimitExceededException_base: S.ErrorClass<ClusterLimitExceededException, S.TaggedStruct<"ClusterLimitExceededException", {
+declare const ClusterLimitExceededException_base: S.Class<ClusterLimitExceededException, S.TaggedStruct<"ClusterLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterLimitExceededException extends ClusterLimitExceededException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly ConflictResource: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ReturnShippingLabelAlreadyExistsException_base: S.ErrorClass<ReturnShippingLabelAlreadyExistsException, S.TaggedStruct<"ReturnShippingLabelAlreadyExistsException", {
+declare const ReturnShippingLabelAlreadyExistsException_base: S.Class<ReturnShippingLabelAlreadyExistsException, S.TaggedStruct<"ReturnShippingLabelAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -673,7 +673,7 @@ declare const ReturnShippingLabelAlreadyExistsException_base: S.ErrorClass<Retur
 });
 export declare class ReturnShippingLabelAlreadyExistsException extends ReturnShippingLabelAlreadyExistsException_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>;
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {

package/lib/services/sns.d.ts

@@ -561,7 +561,7 @@ export declare const VerifySMSSandboxPhoneNumberInput: S.Schema<VerifySMSSandbox
 export interface VerifySMSSandboxPhoneNumberResult {
 }
 export declare const VerifySMSSandboxPhoneNumberResult: S.Schema<VerifySMSSandboxPhoneNumberResult>;
-declare const AuthorizationErrorException_base: S.ErrorClass<AuthorizationErrorException, S.TaggedStruct<"AuthorizationErrorException", {
+declare const AuthorizationErrorException_base: S.Class<AuthorizationErrorException, S.TaggedStruct<"AuthorizationErrorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -570,7 +570,7 @@ declare const AuthorizationErrorException_base: S.ErrorClass<AuthorizationErrorE
 });
 export declare class AuthorizationErrorException extends AuthorizationErrorException_base {
 }
-declare const InternalErrorException_base: S.ErrorClass<InternalErrorException, S.TaggedStruct<"InternalErrorException", {
+declare const InternalErrorException_base: S.Class<InternalErrorException, S.TaggedStruct<"InternalErrorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -579,7 +579,7 @@ declare const InternalErrorException_base: S.ErrorClass<InternalErrorException,
 });
 export declare class InternalErrorException extends InternalErrorException_base {
 }
-declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
+declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -588,7 +588,7 @@ declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterExcep
 });
 export declare class InvalidParameterException extends InvalidParameterException_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": {
@@ -597,21 +597,21 @@ declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedSt
 });
 export declare class NotFoundException extends NotFoundException_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 InvalidClientTokenId_base: S.ErrorClass<InvalidClientTokenId, S.TaggedStruct<"InvalidClientTokenId", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidClientTokenId_base: S.Class<InvalidClientTokenId, S.TaggedStruct<"InvalidClientTokenId", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class InvalidClientTokenId extends InvalidClientTokenId_base {
 }
-declare const ThrottledException_base: S.ErrorClass<ThrottledException, S.TaggedStruct<"ThrottledException", {
+declare const ThrottledException_base: S.Class<ThrottledException, S.TaggedStruct<"ThrottledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -620,7 +620,7 @@ declare const ThrottledException_base: S.ErrorClass<ThrottledException, S.Tagged
 });
 export declare class ThrottledException extends ThrottledException_base {
 }
-declare const FilterPolicyLimitExceededException_base: S.ErrorClass<FilterPolicyLimitExceededException, S.TaggedStruct<"FilterPolicyLimitExceededException", {
+declare const FilterPolicyLimitExceededException_base: S.Class<FilterPolicyLimitExceededException, S.TaggedStruct<"FilterPolicyLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -629,7 +629,7 @@ declare const FilterPolicyLimitExceededException_base: S.ErrorClass<FilterPolicy
 });
 export declare class FilterPolicyLimitExceededException extends FilterPolicyLimitExceededException_base {
 }
-declare const ReplayLimitExceededException_base: S.ErrorClass<ReplayLimitExceededException, S.TaggedStruct<"ReplayLimitExceededException", {
+declare const ReplayLimitExceededException_base: S.Class<ReplayLimitExceededException, S.TaggedStruct<"ReplayLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -638,7 +638,7 @@ declare const ReplayLimitExceededException_base: S.ErrorClass<ReplayLimitExceede
 });
 export declare class ReplayLimitExceededException extends ReplayLimitExceededException_base {
 }
-declare const SubscriptionLimitExceededException_base: S.ErrorClass<SubscriptionLimitExceededException, S.TaggedStruct<"SubscriptionLimitExceededException", {
+declare const SubscriptionLimitExceededException_base: S.Class<SubscriptionLimitExceededException, S.TaggedStruct<"SubscriptionLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -647,7 +647,7 @@ declare const SubscriptionLimitExceededException_base: S.ErrorClass<Subscription
 });
 export declare class SubscriptionLimitExceededException extends SubscriptionLimitExceededException_base {
 }
-declare const OptedOutException_base: S.ErrorClass<OptedOutException, S.TaggedStruct<"OptedOutException", {
+declare const OptedOutException_base: S.Class<OptedOutException, S.TaggedStruct<"OptedOutException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -656,7 +656,7 @@ declare const OptedOutException_base: S.ErrorClass<OptedOutException, S.TaggedSt
 });
 export declare class OptedOutException extends OptedOutException_base {
 }
-declare const UserErrorException_base: S.ErrorClass<UserErrorException, S.TaggedStruct<"UserErrorException", {
+declare const UserErrorException_base: S.Class<UserErrorException, S.TaggedStruct<"UserErrorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -665,7 +665,7 @@ declare const UserErrorException_base: S.ErrorClass<UserErrorException, S.Tagged
 });
 export declare class UserErrorException extends UserErrorException_base {
 }
-declare const ConcurrentAccessException_base: S.ErrorClass<ConcurrentAccessException, S.TaggedStruct<"ConcurrentAccessException", {
+declare const ConcurrentAccessException_base: S.Class<ConcurrentAccessException, S.TaggedStruct<"ConcurrentAccessException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -674,7 +674,7 @@ declare const ConcurrentAccessException_base: S.ErrorClass<ConcurrentAccessExcep
 });
 export declare class ConcurrentAccessException extends ConcurrentAccessException_base {
 }
-declare const InvalidSecurityException_base: S.ErrorClass<InvalidSecurityException, S.TaggedStruct<"InvalidSecurityException", {
+declare const InvalidSecurityException_base: S.Class<InvalidSecurityException, S.TaggedStruct<"InvalidSecurityException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -683,7 +683,7 @@ declare const InvalidSecurityException_base: S.ErrorClass<InvalidSecurityExcepti
 });
 export declare class InvalidSecurityException extends InvalidSecurityException_base {
 }
-declare const StaleTagException_base: S.ErrorClass<StaleTagException, S.TaggedStruct<"StaleTagException", {
+declare const StaleTagException_base: S.Class<StaleTagException, S.TaggedStruct<"StaleTagException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -692,7 +692,7 @@ declare const StaleTagException_base: S.ErrorClass<StaleTagException, S.TaggedSt
 });
 export declare class StaleTagException extends StaleTagException_base {
 }
-declare const TagLimitExceededException_base: S.ErrorClass<TagLimitExceededException, S.TaggedStruct<"TagLimitExceededException", {
+declare const TagLimitExceededException_base: S.Class<TagLimitExceededException, S.TaggedStruct<"TagLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -701,7 +701,7 @@ declare const TagLimitExceededException_base: S.ErrorClass<TagLimitExceededExcep
 });
 export declare class TagLimitExceededException extends TagLimitExceededException_base {
 }
-declare const TagPolicyException_base: S.ErrorClass<TagPolicyException, S.TaggedStruct<"TagPolicyException", {
+declare const TagPolicyException_base: S.Class<TagPolicyException, S.TaggedStruct<"TagPolicyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -710,7 +710,7 @@ declare const TagPolicyException_base: S.ErrorClass<TagPolicyException, S.Tagged
 });
 export declare class TagPolicyException extends TagPolicyException_base {
 }
-declare const TopicLimitExceededException_base: S.ErrorClass<TopicLimitExceededException, S.TaggedStruct<"TopicLimitExceededException", {
+declare const TopicLimitExceededException_base: S.Class<TopicLimitExceededException, S.TaggedStruct<"TopicLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -719,7 +719,7 @@ declare const TopicLimitExceededException_base: S.ErrorClass<TopicLimitExceededE
 });
 export declare class TopicLimitExceededException extends TopicLimitExceededException_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": {
@@ -728,7 +728,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -737,7 +737,7 @@ declare const InvalidStateException_base: S.ErrorClass<InvalidStateException, S.
 });
 export declare class InvalidStateException extends InvalidStateException_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;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -746,7 +746,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const EndpointDisabledException_base: S.ErrorClass<EndpointDisabledException, S.TaggedStruct<"EndpointDisabledException", {
+declare const EndpointDisabledException_base: S.Class<EndpointDisabledException, S.TaggedStruct<"EndpointDisabledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -755,7 +755,7 @@ declare const EndpointDisabledException_base: S.ErrorClass<EndpointDisabledExcep
 });
 export declare class EndpointDisabledException extends EndpointDisabledException_base {
 }
-declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
+declare const InvalidParameterValueException_base: S.Class<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -764,7 +764,7 @@ declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameter
 });
 export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
 }
-declare const KMSAccessDeniedException_base: S.ErrorClass<KMSAccessDeniedException, S.TaggedStruct<"KMSAccessDeniedException", {
+declare const KMSAccessDeniedException_base: S.Class<KMSAccessDeniedException, S.TaggedStruct<"KMSAccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -777,7 +777,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 message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -786,7 +786,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 message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -795,7 +795,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 message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -804,7 +804,7 @@ declare const KMSNotFoundException_base: S.ErrorClass<KMSNotFoundException, S.Ta
 });
 export declare class KMSNotFoundException extends KMSNotFoundException_base {
 }
-declare const KMSOptInRequired_base: S.ErrorClass<KMSOptInRequired, S.TaggedStruct<"KMSOptInRequired", {
+declare const KMSOptInRequired_base: S.Class<KMSOptInRequired, S.TaggedStruct<"KMSOptInRequired", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -813,7 +813,7 @@ declare const KMSOptInRequired_base: S.ErrorClass<KMSOptInRequired, S.TaggedStru
 });
 export declare class KMSOptInRequired extends KMSOptInRequired_base {
 }
-declare const KMSThrottlingException_base: S.ErrorClass<KMSThrottlingException, S.TaggedStruct<"KMSThrottlingException", {
+declare const KMSThrottlingException_base: S.Class<KMSThrottlingException, S.TaggedStruct<"KMSThrottlingException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -822,7 +822,7 @@ declare const KMSThrottlingException_base: S.ErrorClass<KMSThrottlingException,
 });
 export declare class KMSThrottlingException extends KMSThrottlingException_base {
 }
-declare const PlatformApplicationDisabledException_base: S.ErrorClass<PlatformApplicationDisabledException, S.TaggedStruct<"PlatformApplicationDisabledException", {
+declare const PlatformApplicationDisabledException_base: S.Class<PlatformApplicationDisabledException, S.TaggedStruct<"PlatformApplicationDisabledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -831,7 +831,7 @@ declare const PlatformApplicationDisabledException_base: S.ErrorClass<PlatformAp
 });
 export declare class PlatformApplicationDisabledException extends PlatformApplicationDisabledException_base {
 }
-declare const BatchEntryIdsNotDistinctException_base: S.ErrorClass<BatchEntryIdsNotDistinctException, S.TaggedStruct<"BatchEntryIdsNotDistinctException", {
+declare const BatchEntryIdsNotDistinctException_base: S.Class<BatchEntryIdsNotDistinctException, S.TaggedStruct<"BatchEntryIdsNotDistinctException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -840,7 +840,7 @@ declare const BatchEntryIdsNotDistinctException_base: S.ErrorClass<BatchEntryIds
 });
 export declare class BatchEntryIdsNotDistinctException extends BatchEntryIdsNotDistinctException_base {
 }
-declare const BatchRequestTooLongException_base: S.ErrorClass<BatchRequestTooLongException, S.TaggedStruct<"BatchRequestTooLongException", {
+declare const BatchRequestTooLongException_base: S.Class<BatchRequestTooLongException, S.TaggedStruct<"BatchRequestTooLongException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -849,7 +849,7 @@ declare const BatchRequestTooLongException_base: S.ErrorClass<BatchRequestTooLon
 });
 export declare class BatchRequestTooLongException extends BatchRequestTooLongException_base {
 }
-declare const EmptyBatchRequestException_base: S.ErrorClass<EmptyBatchRequestException, S.TaggedStruct<"EmptyBatchRequestException", {
+declare const EmptyBatchRequestException_base: S.Class<EmptyBatchRequestException, S.TaggedStruct<"EmptyBatchRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -858,7 +858,7 @@ declare const EmptyBatchRequestException_base: S.ErrorClass<EmptyBatchRequestExc
 });
 export declare class EmptyBatchRequestException extends EmptyBatchRequestException_base {
 }
-declare const InvalidBatchEntryIdException_base: S.ErrorClass<InvalidBatchEntryIdException, S.TaggedStruct<"InvalidBatchEntryIdException", {
+declare const InvalidBatchEntryIdException_base: S.Class<InvalidBatchEntryIdException, S.TaggedStruct<"InvalidBatchEntryIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -867,7 +867,7 @@ declare const InvalidBatchEntryIdException_base: S.ErrorClass<InvalidBatchEntryI
 });
 export declare class InvalidBatchEntryIdException extends InvalidBatchEntryIdException_base {
 }
-declare const TooManyEntriesInBatchRequestException_base: S.ErrorClass<TooManyEntriesInBatchRequestException, S.TaggedStruct<"TooManyEntriesInBatchRequestException", {
+declare const TooManyEntriesInBatchRequestException_base: S.Class<TooManyEntriesInBatchRequestException, S.TaggedStruct<"TooManyEntriesInBatchRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -876,7 +876,7 @@ declare const TooManyEntriesInBatchRequestException_base: S.ErrorClass<TooManyEn
 });
 export declare class TooManyEntriesInBatchRequestException extends TooManyEntriesInBatchRequestException_base {
 }
-declare const VerificationException_base: S.ErrorClass<VerificationException, S.TaggedStruct<"VerificationException", {
+declare const VerificationException_base: S.Class<VerificationException, S.TaggedStruct<"VerificationException", {
     readonly Message: S.String;
     readonly Status: S.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/socialmessaging.d.ts

@@ -485,7 +485,7 @@ export interface SendWhatsAppMessageOutput {
     messageId?: string;
 }
 export declare const SendWhatsAppMessageOutput: S.Schema<SendWhatsAppMessageOutput>;
-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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -498,7 +498,7 @@ declare const InternalServiceException_base: S.ErrorClass<InternalServiceExcepti
 });
 export declare class InternalServiceException extends InternalServiceException_base {
 }
-declare const InvalidParametersException_base: S.ErrorClass<InvalidParametersException, S.TaggedStruct<"InvalidParametersException", {
+declare const InvalidParametersException_base: S.Class<InvalidParametersException, S.TaggedStruct<"InvalidParametersException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -507,7 +507,7 @@ declare const InvalidParametersException_base: S.ErrorClass<InvalidParametersExc
 });
 export declare class InvalidParametersException extends InvalidParametersException_base {
 }
-declare const ThrottledRequestException_base: S.ErrorClass<ThrottledRequestException, S.TaggedStruct<"ThrottledRequestException", {
+declare const ThrottledRequestException_base: S.Class<ThrottledRequestException, S.TaggedStruct<"ThrottledRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -520,7 +520,7 @@ declare const ThrottledRequestException_base: S.ErrorClass<ThrottledRequestExcep
 });
 export declare class ThrottledRequestException extends ThrottledRequestException_base {
 }
-declare const DependencyException_base: S.ErrorClass<DependencyException, S.TaggedStruct<"DependencyException", {
+declare const DependencyException_base: S.Class<DependencyException, S.TaggedStruct<"DependencyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -533,7 +533,7 @@ declare const DependencyException_base: S.ErrorClass<DependencyException, S.Tagg
 });
 export declare class DependencyException extends DependencyException_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": {
@@ -542,7 +542,7 @@ declare const LimitExceededException_base: S.ErrorClass<LimitExceededException,
 });
 export declare class LimitExceededException extends LimitExceededException_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": {
@@ -551,7 +551,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const AccessDeniedByMetaException_base: S.ErrorClass<AccessDeniedByMetaException, S.TaggedStruct<"AccessDeniedByMetaException", {
+declare const AccessDeniedByMetaException_base: S.Class<AccessDeniedByMetaException, S.TaggedStruct<"AccessDeniedByMetaException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {