@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/s3.d.ts

@@ -3109,37 +3109,37 @@ export declare const WriteGetObjectResponseRequest: S.Schema<WriteGetObjectRespo
 export interface WriteGetObjectResponseResponse {
 }
 export declare const WriteGetObjectResponseResponse: S.Schema<WriteGetObjectResponseResponse>;
-declare const NoSuchUpload_base: S.ErrorClass<NoSuchUpload, S.TaggedStruct<"NoSuchUpload", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const NoSuchUpload_base: S.Class<NoSuchUpload, S.TaggedStruct<"NoSuchUpload", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class NoSuchUpload extends NoSuchUpload_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 NoSuchBucket_base: S.ErrorClass<NoSuchBucket, S.TaggedStruct<"NoSuchBucket", {
+declare const NoSuchBucket_base: S.Class<NoSuchBucket, S.TaggedStruct<"NoSuchBucket", {
     readonly Message: S.optional<S.String>;
     readonly BucketName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchBucket extends NoSuchBucket_base {
 }
-declare const NotFound_base: S.ErrorClass<NotFound, S.TaggedStruct<"NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const NotFound_base: S.Class<NotFound, S.TaggedStruct<"NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class NotFound extends NotFound_base {
 }
-declare const ObjectNotInActiveTierError_base: S.ErrorClass<ObjectNotInActiveTierError, S.TaggedStruct<"ObjectNotInActiveTierError", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const ObjectNotInActiveTierError_base: S.Class<ObjectNotInActiveTierError, S.TaggedStruct<"ObjectNotInActiveTierError", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class ObjectNotInActiveTierError extends ObjectNotInActiveTierError_base {
 }
-declare const PermanentRedirect_base: S.ErrorClass<PermanentRedirect, S.TaggedStruct<"PermanentRedirect", {
+declare const PermanentRedirect_base: S.Class<PermanentRedirect, S.TaggedStruct<"PermanentRedirect", {
     readonly BucketRegion: S.optional<S.String>;
     readonly Endpoint: S.optional<S.String>;
     readonly Bucket: S.optional<S.String>;
@@ -3147,7 +3147,7 @@ declare const PermanentRedirect_base: S.ErrorClass<PermanentRedirect, S.TaggedSt
 }>, import("effect/Cause").YieldableError>;
 export declare class PermanentRedirect extends PermanentRedirect_base {
 }
-declare const BucketAlreadyExists_base: S.ErrorClass<BucketAlreadyExists, S.TaggedStruct<"BucketAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const BucketAlreadyExists_base: S.Class<BucketAlreadyExists, S.TaggedStruct<"BucketAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ConflictError: true;
     };
@@ -3158,66 +3158,66 @@ declare const BucketAlreadyExists_base: S.ErrorClass<BucketAlreadyExists, S.Tagg
 });
 export declare class BucketAlreadyExists extends BucketAlreadyExists_base {
 }
-declare const BucketAlreadyOwnedByYou_base: S.ErrorClass<BucketAlreadyOwnedByYou, S.TaggedStruct<"BucketAlreadyOwnedByYou", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const BucketAlreadyOwnedByYou_base: S.Class<BucketAlreadyOwnedByYou, S.TaggedStruct<"BucketAlreadyOwnedByYou", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ConflictError: true;
     };
 });
 export declare class BucketAlreadyOwnedByYou extends BucketAlreadyOwnedByYou_base {
 }
-declare const IllegalLocationConstraintException_base: S.ErrorClass<IllegalLocationConstraintException, S.TaggedStruct<"IllegalLocationConstraintException", {}>, import("effect/Cause").YieldableError>;
+declare const IllegalLocationConstraintException_base: S.Class<IllegalLocationConstraintException, S.TaggedStruct<"IllegalLocationConstraintException", {}>, import("effect/Cause").YieldableError>;
 export declare class IllegalLocationConstraintException extends IllegalLocationConstraintException_base {
 }
-declare const InvalidArgument_base: S.ErrorClass<InvalidArgument, S.TaggedStruct<"InvalidArgument", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidArgument_base: S.Class<InvalidArgument, S.TaggedStruct<"InvalidArgument", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidArgument extends InvalidArgument_base {
 }
-declare const InvalidBucketName_base: S.ErrorClass<InvalidBucketName, S.TaggedStruct<"InvalidBucketName", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidBucketName_base: S.Class<InvalidBucketName, S.TaggedStruct<"InvalidBucketName", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidBucketName extends InvalidBucketName_base {
 }
-declare const InvalidLocationConstraint_base: S.ErrorClass<InvalidLocationConstraint, S.TaggedStruct<"InvalidLocationConstraint", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocationConstraint_base: S.Class<InvalidLocationConstraint, S.TaggedStruct<"InvalidLocationConstraint", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocationConstraint extends InvalidLocationConstraint_base {
 }
-declare const BucketNotEmpty_base: S.ErrorClass<BucketNotEmpty, S.TaggedStruct<"BucketNotEmpty", {}>, import("effect/Cause").YieldableError>;
+declare const BucketNotEmpty_base: S.Class<BucketNotEmpty, S.TaggedStruct<"BucketNotEmpty", {}>, import("effect/Cause").YieldableError>;
 export declare class BucketNotEmpty extends BucketNotEmpty_base {
 }
-declare const SignatureDoesNotMatch_base: S.ErrorClass<SignatureDoesNotMatch, S.TaggedStruct<"SignatureDoesNotMatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const SignatureDoesNotMatch_base: S.Class<SignatureDoesNotMatch, S.TaggedStruct<"SignatureDoesNotMatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class SignatureDoesNotMatch extends SignatureDoesNotMatch_base {
 }
-declare const NoSuchKey_base: S.ErrorClass<NoSuchKey, S.TaggedStruct<"NoSuchKey", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchKey_base: S.Class<NoSuchKey, S.TaggedStruct<"NoSuchKey", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchKey extends NoSuchKey_base {
 }
-declare const NoSuchConfiguration_base: S.ErrorClass<NoSuchConfiguration, S.TaggedStruct<"NoSuchConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchConfiguration_base: S.Class<NoSuchConfiguration, S.TaggedStruct<"NoSuchConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConfiguration extends NoSuchConfiguration_base {
 }
-declare const NoSuchCORSConfiguration_base: S.ErrorClass<NoSuchCORSConfiguration, S.TaggedStruct<"NoSuchCORSConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchCORSConfiguration_base: S.Class<NoSuchCORSConfiguration, S.TaggedStruct<"NoSuchCORSConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchCORSConfiguration extends NoSuchCORSConfiguration_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 NoSuchLifecycleConfiguration_base: S.ErrorClass<NoSuchLifecycleConfiguration, S.TaggedStruct<"NoSuchLifecycleConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchLifecycleConfiguration_base: S.Class<NoSuchLifecycleConfiguration, S.TaggedStruct<"NoSuchLifecycleConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchLifecycleConfiguration extends NoSuchLifecycleConfiguration_base {
 }
-declare const OwnershipControlsNotFoundError_base: S.ErrorClass<OwnershipControlsNotFoundError, S.TaggedStruct<"OwnershipControlsNotFoundError", {}>, import("effect/Cause").YieldableError>;
+declare const OwnershipControlsNotFoundError_base: S.Class<OwnershipControlsNotFoundError, S.TaggedStruct<"OwnershipControlsNotFoundError", {}>, import("effect/Cause").YieldableError>;
 export declare class OwnershipControlsNotFoundError extends OwnershipControlsNotFoundError_base {
 }
-declare const NoSuchBucketPolicy_base: S.ErrorClass<NoSuchBucketPolicy, S.TaggedStruct<"NoSuchBucketPolicy", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchBucketPolicy_base: S.Class<NoSuchBucketPolicy, S.TaggedStruct<"NoSuchBucketPolicy", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchBucketPolicy extends NoSuchBucketPolicy_base {
 }
-declare const ReplicationConfigurationNotFoundError_base: S.ErrorClass<ReplicationConfigurationNotFoundError, S.TaggedStruct<"ReplicationConfigurationNotFoundError", {}>, import("effect/Cause").YieldableError>;
+declare const ReplicationConfigurationNotFoundError_base: S.Class<ReplicationConfigurationNotFoundError, S.TaggedStruct<"ReplicationConfigurationNotFoundError", {}>, import("effect/Cause").YieldableError>;
 export declare class ReplicationConfigurationNotFoundError extends ReplicationConfigurationNotFoundError_base {
 }
-declare const NoSuchTagSet_base: S.ErrorClass<NoSuchTagSet, S.TaggedStruct<"NoSuchTagSet", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchTagSet_base: S.Class<NoSuchTagSet, S.TaggedStruct<"NoSuchTagSet", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchTagSet extends NoSuchTagSet_base {
 }
-declare const NoSuchWebsiteConfiguration_base: S.ErrorClass<NoSuchWebsiteConfiguration, S.TaggedStruct<"NoSuchWebsiteConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchWebsiteConfiguration_base: S.Class<NoSuchWebsiteConfiguration, S.TaggedStruct<"NoSuchWebsiteConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchWebsiteConfiguration extends NoSuchWebsiteConfiguration_base {
 }
-declare const InvalidObjectState_base: S.ErrorClass<InvalidObjectState, S.TaggedStruct<"InvalidObjectState", {
+declare const InvalidObjectState_base: S.Class<InvalidObjectState, S.TaggedStruct<"InvalidObjectState", {
     readonly StorageClass: S.optional<S.String>;
     readonly AccessTier: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3227,66 +3227,66 @@ declare const InvalidObjectState_base: S.ErrorClass<InvalidObjectState, S.Tagged
 });
 export declare class InvalidObjectState extends InvalidObjectState_base {
 }
-declare const InvalidRequest_base: S.ErrorClass<InvalidRequest, S.TaggedStruct<"InvalidRequest", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRequest_base: S.Class<InvalidRequest, S.TaggedStruct<"InvalidRequest", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequest extends InvalidRequest_base {
 }
-declare const ObjectLockConfigurationNotFoundError_base: S.ErrorClass<ObjectLockConfigurationNotFoundError, S.TaggedStruct<"ObjectLockConfigurationNotFoundError", {}>, import("effect/Cause").YieldableError>;
+declare const ObjectLockConfigurationNotFoundError_base: S.Class<ObjectLockConfigurationNotFoundError, S.TaggedStruct<"ObjectLockConfigurationNotFoundError", {}>, import("effect/Cause").YieldableError>;
 export declare class ObjectLockConfigurationNotFoundError extends ObjectLockConfigurationNotFoundError_base {
 }
-declare const NoSuchPublicAccessBlockConfiguration_base: S.ErrorClass<NoSuchPublicAccessBlockConfiguration, S.TaggedStruct<"NoSuchPublicAccessBlockConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const NoSuchPublicAccessBlockConfiguration_base: S.Class<NoSuchPublicAccessBlockConfiguration, S.TaggedStruct<"NoSuchPublicAccessBlockConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class NoSuchPublicAccessBlockConfiguration extends NoSuchPublicAccessBlockConfiguration_base {
 }
-declare const RequestError_base: S.ErrorClass<RequestError, S.TaggedStruct<"RequestError", {}>, import("effect/Cause").YieldableError>;
+declare const RequestError_base: S.Class<RequestError, S.TaggedStruct<"RequestError", {}>, import("effect/Cause").YieldableError>;
 export declare class RequestError extends RequestError_base {
 }
-declare const MalformedXML_base: S.ErrorClass<MalformedXML, S.TaggedStruct<"MalformedXML", {}>, import("effect/Cause").YieldableError>;
+declare const MalformedXML_base: S.Class<MalformedXML, S.TaggedStruct<"MalformedXML", {}>, import("effect/Cause").YieldableError>;
 export declare class MalformedXML extends MalformedXML_base {
 }
-declare const AccessDenied_base: S.ErrorClass<AccessDenied, S.TaggedStruct<"AccessDenied", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const AccessDenied_base: S.Class<AccessDenied, S.TaggedStruct<"AccessDenied", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class AccessDenied extends AccessDenied_base {
 }
-declare const InvalidDigest_base: S.ErrorClass<InvalidDigest, S.TaggedStruct<"InvalidDigest", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidDigest_base: S.Class<InvalidDigest, S.TaggedStruct<"InvalidDigest", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidDigest extends InvalidDigest_base {
 }
-declare const MalformedPolicy_base: S.ErrorClass<MalformedPolicy, S.TaggedStruct<"MalformedPolicy", {}>, import("effect/Cause").YieldableError>;
+declare const MalformedPolicy_base: S.Class<MalformedPolicy, S.TaggedStruct<"MalformedPolicy", {}>, import("effect/Cause").YieldableError>;
 export declare class MalformedPolicy extends MalformedPolicy_base {
 }
-declare const EncryptionTypeMismatch_base: S.ErrorClass<EncryptionTypeMismatch, S.TaggedStruct<"EncryptionTypeMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const EncryptionTypeMismatch_base: S.Class<EncryptionTypeMismatch, S.TaggedStruct<"EncryptionTypeMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class EncryptionTypeMismatch extends EncryptionTypeMismatch_base {
 }
-declare const InvalidWriteOffset_base: S.ErrorClass<InvalidWriteOffset, S.TaggedStruct<"InvalidWriteOffset", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidWriteOffset_base: S.Class<InvalidWriteOffset, S.TaggedStruct<"InvalidWriteOffset", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class InvalidWriteOffset extends InvalidWriteOffset_base {
 }
-declare const TooManyParts_base: S.ErrorClass<TooManyParts, S.TaggedStruct<"TooManyParts", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const TooManyParts_base: S.Class<TooManyParts, S.TaggedStruct<"TooManyParts", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class TooManyParts extends TooManyParts_base {
 }
-declare const InvalidBucketState_base: S.ErrorClass<InvalidBucketState, S.TaggedStruct<"InvalidBucketState", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidBucketState_base: S.Class<InvalidBucketState, S.TaggedStruct<"InvalidBucketState", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidBucketState extends InvalidBucketState_base {
 }
-declare const IdempotencyParameterMismatch_base: S.ErrorClass<IdempotencyParameterMismatch, S.TaggedStruct<"IdempotencyParameterMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const IdempotencyParameterMismatch_base: S.Class<IdempotencyParameterMismatch, S.TaggedStruct<"IdempotencyParameterMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         BadRequestError: true;
     };
 });
 export declare class IdempotencyParameterMismatch extends IdempotencyParameterMismatch_base {
 }
-declare const ObjectAlreadyInActiveTierError_base: S.ErrorClass<ObjectAlreadyInActiveTierError, S.TaggedStruct<"ObjectAlreadyInActiveTierError", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const ObjectAlreadyInActiveTierError_base: S.Class<ObjectAlreadyInActiveTierError, S.TaggedStruct<"ObjectAlreadyInActiveTierError", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };

package/lib/services/s3outposts.d.ts

@@ -117,7 +117,7 @@ export interface ListSharedEndpointsResult {
     NextToken?: string;
 }
 export declare const ListSharedEndpointsResult: S.Schema<ListSharedEndpointsResult>;
-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": {
@@ -126,7 +126,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": {
@@ -135,7 +135,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_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": {
@@ -144,7 +144,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const OutpostOfflineException_base: S.ErrorClass<OutpostOfflineException, S.TaggedStruct<"OutpostOfflineException", {
+declare const OutpostOfflineException_base: S.Class<OutpostOfflineException, S.TaggedStruct<"OutpostOfflineException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -153,7 +153,7 @@ declare const OutpostOfflineException_base: S.ErrorClass<OutpostOfflineException
 });
 export declare class OutpostOfflineException extends OutpostOfflineException_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": {
@@ -162,7 +162,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -171,7 +171,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": {

package/lib/services/s3tables.d.ts

@@ -807,7 +807,7 @@ export interface UpdateTableMetadataLocationResponse {
     metadataLocation: string;
 }
 export declare const UpdateTableMetadataLocationResponse: S.Schema<UpdateTableMetadataLocationResponse>;
-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": {
@@ -816,7 +816,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": {
@@ -825,7 +825,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ForbiddenException_base: S.ErrorClass<ForbiddenException, S.TaggedStruct<"ForbiddenException", {
+declare const ForbiddenException_base: S.Class<ForbiddenException, S.TaggedStruct<"ForbiddenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -834,7 +834,7 @@ declare const ForbiddenException_base: S.ErrorClass<ForbiddenException, S.Tagged
 });
 export declare class ForbiddenException extends ForbiddenException_base {
 }
-declare const InternalServerErrorException_base: S.ErrorClass<InternalServerErrorException, S.TaggedStruct<"InternalServerErrorException", {
+declare const InternalServerErrorException_base: S.Class<InternalServerErrorException, S.TaggedStruct<"InternalServerErrorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -843,7 +843,7 @@ declare const InternalServerErrorException_base: S.ErrorClass<InternalServerErro
 });
 export declare class InternalServerErrorException extends InternalServerErrorException_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": {
@@ -852,7 +852,7 @@ declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedSt
 });
 export declare class NotFoundException extends NotFoundException_base {
 }
-declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
+declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -861,7 +861,7 @@ declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsExcepti
 });
 export declare class TooManyRequestsException extends TooManyRequestsException_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": {
@@ -870,7 +870,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const MethodNotAllowedException_base: S.ErrorClass<MethodNotAllowedException, S.TaggedStruct<"MethodNotAllowedException", {
+declare const MethodNotAllowedException_base: S.Class<MethodNotAllowedException, S.TaggedStruct<"MethodNotAllowedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/s3vectors.d.ts

@@ -343,7 +343,7 @@ export interface QueryVectorsOutput {
     distanceMetric: DistanceMetric;
 }
 export declare const QueryVectorsOutput: S.Schema<QueryVectorsOutput>;
-declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedStruct<"NotFoundException", {
+declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -352,7 +352,7 @@ declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedSt
 });
 export declare class NotFoundException extends NotFoundException_base {
 }
-declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
+declare const ServiceUnavailableException_base: S.Class<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -365,7 +365,7 @@ declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableE
 });
 export declare class ServiceUnavailableException extends ServiceUnavailableException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -374,7 +374,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_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": {
@@ -383,7 +383,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_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": {
@@ -392,7 +392,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const KmsDisabledException_base: S.ErrorClass<KmsDisabledException, S.TaggedStruct<"KmsDisabledException", {
+declare const KmsDisabledException_base: S.Class<KmsDisabledException, S.TaggedStruct<"KmsDisabledException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -401,7 +401,7 @@ declare const KmsDisabledException_base: S.ErrorClass<KmsDisabledException, S.Ta
 });
 export declare class KmsDisabledException extends KmsDisabledException_base {
 }
-declare const KmsInvalidKeyUsageException_base: S.ErrorClass<KmsInvalidKeyUsageException, S.TaggedStruct<"KmsInvalidKeyUsageException", {
+declare const KmsInvalidKeyUsageException_base: S.Class<KmsInvalidKeyUsageException, S.TaggedStruct<"KmsInvalidKeyUsageException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -410,7 +410,7 @@ declare const KmsInvalidKeyUsageException_base: S.ErrorClass<KmsInvalidKeyUsageE
 });
 export declare class KmsInvalidKeyUsageException extends KmsInvalidKeyUsageException_base {
 }
-declare const KmsInvalidStateException_base: S.ErrorClass<KmsInvalidStateException, S.TaggedStruct<"KmsInvalidStateException", {
+declare const KmsInvalidStateException_base: S.Class<KmsInvalidStateException, S.TaggedStruct<"KmsInvalidStateException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -419,7 +419,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/sagemaker-a2i-runtime.d.ts

@@ -98,7 +98,7 @@ export declare const StopHumanLoopRequest: S.Schema<StopHumanLoopRequest>;
 export interface StopHumanLoopResponse {
 }
 export declare const StopHumanLoopResponse: S.Schema<StopHumanLoopResponse>;
-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": {
@@ -107,7 +107,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": {
@@ -116,7 +116,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -125,7 +125,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": {
@@ -134,7 +134,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": {
@@ -143,7 +143,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_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": {

package/lib/services/sagemaker-edge.d.ts

@@ -122,7 +122,7 @@ export declare const SendHeartbeatRequest: S.Schema<SendHeartbeatRequest>;
 export interface SendHeartbeatResponse {
 }
 export declare const SendHeartbeatResponse: S.Schema<SendHeartbeatResponse>;
-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 {

package/lib/services/sagemaker-featurestore-runtime.d.ts

@@ -127,7 +127,7 @@ export declare const PutRecordRequest: S.Schema<PutRecordRequest>;
 export interface PutRecordResponse {
 }
 export declare const PutRecordResponse: S.Schema<PutRecordResponse>;
-declare const AccessForbidden_base: S.ErrorClass<AccessForbidden, S.TaggedStruct<"AccessForbidden", {
+declare const AccessForbidden_base: S.Class<AccessForbidden, S.TaggedStruct<"AccessForbidden", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -136,7 +136,7 @@ declare const AccessForbidden_base: S.ErrorClass<AccessForbidden, S.TaggedStruct
 });
 export declare class AccessForbidden extends AccessForbidden_base {
 }
-declare const InternalFailure_base: S.ErrorClass<InternalFailure, S.TaggedStruct<"InternalFailure", {
+declare const InternalFailure_base: S.Class<InternalFailure, S.TaggedStruct<"InternalFailure", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -145,7 +145,7 @@ declare const InternalFailure_base: S.ErrorClass<InternalFailure, S.TaggedStruct
 });
 export declare class InternalFailure extends InternalFailure_base {
 }
-declare const ServiceUnavailable_base: S.ErrorClass<ServiceUnavailable, S.TaggedStruct<"ServiceUnavailable", {
+declare const ServiceUnavailable_base: S.Class<ServiceUnavailable, S.TaggedStruct<"ServiceUnavailable", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -154,7 +154,7 @@ declare const ServiceUnavailable_base: S.ErrorClass<ServiceUnavailable, S.Tagged
 });
 export declare class ServiceUnavailable extends ServiceUnavailable_base {
 }
-declare const ValidationError_base: S.ErrorClass<ValidationError, S.TaggedStruct<"ValidationError", {
+declare const ValidationError_base: S.Class<ValidationError, S.TaggedStruct<"ValidationError", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -163,7 +163,7 @@ declare const ValidationError_base: S.ErrorClass<ValidationError, S.TaggedStruct
 });
 export declare class ValidationError extends ValidationError_base {
 }
-declare const ResourceNotFound_base: S.ErrorClass<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
+declare const ResourceNotFound_base: S.Class<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/sagemaker-geospatial.d.ts

@@ -855,7 +855,7 @@ export declare const StopVectorEnrichmentJobInput: S.Schema<StopVectorEnrichment
 export interface StopVectorEnrichmentJobOutput {
 }
 export declare const StopVectorEnrichmentJobOutput: S.Schema<StopVectorEnrichmentJobOutput>;
-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": {
@@ -864,7 +864,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly Message: S.String;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -874,7 +874,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;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -884,7 +884,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.String;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -894,7 +894,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.String;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -904,7 +904,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.String;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -914,7 +914,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.String;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {