@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/devops-guru.d.ts

@@ -1174,7 +1174,7 @@ export declare const UpdateServiceIntegrationRequest: S.Schema<UpdateServiceInte
 export interface UpdateServiceIntegrationResponse {
 }
 export declare const UpdateServiceIntegrationResponse: S.Schema<UpdateServiceIntegrationResponse>;
-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": {
@@ -1183,7 +1183,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.String;
     readonly ResourceId: S.String;
     readonly ResourceType: S.String;
@@ -1194,7 +1194,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.String;
     readonly RetryAfterSeconds: S.optional<S.Number>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1204,7 +1204,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.String;
     readonly ResourceType: S.String;
@@ -1215,7 +1215,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1224,7 +1224,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.String;
     readonly QuotaCode: S.optional<S.String>;
     readonly ServiceCode: S.optional<S.String>;
@@ -1236,7 +1236,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 Reason: S.optional<S.String>;
     readonly Fields: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;

package/lib/services/direct-connect.d.ts

@@ -1042,12 +1042,12 @@ export interface UpdateVirtualInterfaceAttributesRequest {
     virtualInterfaceName?: string;
 }
 export declare const UpdateVirtualInterfaceAttributesRequest: S.Schema<UpdateVirtualInterfaceAttributesRequest>;
-declare const DirectConnectClientException_base: S.ErrorClass<DirectConnectClientException, S.TaggedStruct<"DirectConnectClientException", {
+declare const DirectConnectClientException_base: S.Class<DirectConnectClientException, S.TaggedStruct<"DirectConnectClientException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectConnectClientException extends DirectConnectClientException_base {
 }
-declare const DirectConnectServerException_base: S.ErrorClass<DirectConnectServerException, S.TaggedStruct<"DirectConnectServerException", {
+declare const DirectConnectServerException_base: S.Class<DirectConnectServerException, S.TaggedStruct<"DirectConnectServerException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1056,12 +1056,12 @@ declare const DirectConnectServerException_base: S.ErrorClass<DirectConnectServe
 });
 export declare class DirectConnectServerException extends DirectConnectServerException_base {
 }
-declare const DuplicateTagKeysException_base: S.ErrorClass<DuplicateTagKeysException, S.TaggedStruct<"DuplicateTagKeysException", {
+declare const DuplicateTagKeysException_base: S.Class<DuplicateTagKeysException, S.TaggedStruct<"DuplicateTagKeysException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicateTagKeysException extends DuplicateTagKeysException_base {
 }
-declare const TooManyTagsException_base: S.ErrorClass<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
+declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TooManyTagsException extends TooManyTagsException_base {

package/lib/services/directory-service-data.d.ts

@@ -394,7 +394,7 @@ export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
 export interface UpdateUserResult {
 }
 export declare const UpdateUserResult: S.Schema<UpdateUserResult>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -404,7 +404,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": {
@@ -413,7 +413,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const DirectoryUnavailableException_base: S.ErrorClass<DirectoryUnavailableException, S.TaggedStruct<"DirectoryUnavailableException", {
+declare const DirectoryUnavailableException_base: S.Class<DirectoryUnavailableException, S.TaggedStruct<"DirectoryUnavailableException", {
     readonly Message: S.optional<S.String>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -427,7 +427,7 @@ declare const DirectoryUnavailableException_base: S.ErrorClass<DirectoryUnavaila
 });
 export declare class DirectoryUnavailableException extends DirectoryUnavailableException_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": {
@@ -440,7 +440,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": {
@@ -449,7 +449,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 RetryAfterSeconds: S.optional<S.Number>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -463,7 +463,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>;
     readonly Reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/directory-service.d.ts

@@ -1464,43 +1464,43 @@ export interface VerifyTrustResult {
     TrustId?: string;
 }
 export declare const VerifyTrustResult: S.Schema<VerifyTrustResult>;
-declare const ClientException_base: S.ErrorClass<ClientException, S.TaggedStruct<"ClientException", {
+declare const ClientException_base: S.Class<ClientException, S.TaggedStruct<"ClientException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClientException extends ClientException_base {
 }
-declare const DirectoryAlreadySharedException_base: S.ErrorClass<DirectoryAlreadySharedException, S.TaggedStruct<"DirectoryAlreadySharedException", {
+declare const DirectoryAlreadySharedException_base: S.Class<DirectoryAlreadySharedException, S.TaggedStruct<"DirectoryAlreadySharedException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryAlreadySharedException extends DirectoryAlreadySharedException_base {
 }
-declare const EntityDoesNotExistException_base: S.ErrorClass<EntityDoesNotExistException, S.TaggedStruct<"EntityDoesNotExistException", {
+declare const EntityDoesNotExistException_base: S.Class<EntityDoesNotExistException, S.TaggedStruct<"EntityDoesNotExistException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EntityDoesNotExistException extends EntityDoesNotExistException_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>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterException extends InvalidParameterException_base {
 }
-declare const ServiceException_base: S.ErrorClass<ServiceException, S.TaggedStruct<"ServiceException", {
+declare const ServiceException_base: S.Class<ServiceException, S.TaggedStruct<"ServiceException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceException extends ServiceException_base {
 }
-declare const DirectoryUnavailableException_base: S.ErrorClass<DirectoryUnavailableException, S.TaggedStruct<"DirectoryUnavailableException", {
+declare const DirectoryUnavailableException_base: S.Class<DirectoryUnavailableException, S.TaggedStruct<"DirectoryUnavailableException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryUnavailableException extends DirectoryUnavailableException_base {
 }
-declare const EntityAlreadyExistsException_base: S.ErrorClass<EntityAlreadyExistsException, S.TaggedStruct<"EntityAlreadyExistsException", {
+declare const EntityAlreadyExistsException_base: S.Class<EntityAlreadyExistsException, S.TaggedStruct<"EntityAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1510,13 +1510,13 @@ declare const EntityAlreadyExistsException_base: S.ErrorClass<EntityAlreadyExist
 });
 export declare class EntityAlreadyExistsException extends EntityAlreadyExistsException_base {
 }
-declare const IpRouteLimitExceededException_base: S.ErrorClass<IpRouteLimitExceededException, S.TaggedStruct<"IpRouteLimitExceededException", {
+declare const IpRouteLimitExceededException_base: S.Class<IpRouteLimitExceededException, S.TaggedStruct<"IpRouteLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IpRouteLimitExceededException extends IpRouteLimitExceededException_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>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1526,121 +1526,121 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const DirectoryAlreadyInRegionException_base: S.ErrorClass<DirectoryAlreadyInRegionException, S.TaggedStruct<"DirectoryAlreadyInRegionException", {
+declare const DirectoryAlreadyInRegionException_base: S.Class<DirectoryAlreadyInRegionException, S.TaggedStruct<"DirectoryAlreadyInRegionException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryAlreadyInRegionException extends DirectoryAlreadyInRegionException_base {
 }
-declare const DirectoryDoesNotExistException_base: S.ErrorClass<DirectoryDoesNotExistException, S.TaggedStruct<"DirectoryDoesNotExistException", {
+declare const DirectoryDoesNotExistException_base: S.Class<DirectoryDoesNotExistException, S.TaggedStruct<"DirectoryDoesNotExistException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryDoesNotExistException extends DirectoryDoesNotExistException_base {
 }
-declare const RegionLimitExceededException_base: S.ErrorClass<RegionLimitExceededException, S.TaggedStruct<"RegionLimitExceededException", {
+declare const RegionLimitExceededException_base: S.Class<RegionLimitExceededException, S.TaggedStruct<"RegionLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RegionLimitExceededException extends RegionLimitExceededException_base {
 }
-declare const UnsupportedOperationException_base: S.ErrorClass<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
+declare const UnsupportedOperationException_base: S.Class<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperationException extends UnsupportedOperationException_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>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagLimitExceededException extends TagLimitExceededException_base {
 }
-declare const DirectoryLimitExceededException_base: S.ErrorClass<DirectoryLimitExceededException, S.TaggedStruct<"DirectoryLimitExceededException", {
+declare const DirectoryLimitExceededException_base: S.Class<DirectoryLimitExceededException, S.TaggedStruct<"DirectoryLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryLimitExceededException extends DirectoryLimitExceededException_base {
 }
-declare const AuthenticationFailedException_base: S.ErrorClass<AuthenticationFailedException, S.TaggedStruct<"AuthenticationFailedException", {
+declare const AuthenticationFailedException_base: S.Class<AuthenticationFailedException, S.TaggedStruct<"AuthenticationFailedException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AuthenticationFailedException extends AuthenticationFailedException_base {
 }
-declare const ADAssessmentLimitExceededException_base: S.ErrorClass<ADAssessmentLimitExceededException, S.TaggedStruct<"ADAssessmentLimitExceededException", {
+declare const ADAssessmentLimitExceededException_base: S.Class<ADAssessmentLimitExceededException, S.TaggedStruct<"ADAssessmentLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ADAssessmentLimitExceededException extends ADAssessmentLimitExceededException_base {
 }
-declare const InsufficientPermissionsException_base: S.ErrorClass<InsufficientPermissionsException, S.TaggedStruct<"InsufficientPermissionsException", {
+declare const InsufficientPermissionsException_base: S.Class<InsufficientPermissionsException, S.TaggedStruct<"InsufficientPermissionsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InsufficientPermissionsException extends InsufficientPermissionsException_base {
 }
-declare const SnapshotLimitExceededException_base: S.ErrorClass<SnapshotLimitExceededException, S.TaggedStruct<"SnapshotLimitExceededException", {
+declare const SnapshotLimitExceededException_base: S.Class<SnapshotLimitExceededException, S.TaggedStruct<"SnapshotLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SnapshotLimitExceededException extends SnapshotLimitExceededException_base {
 }
-declare const CertificateDoesNotExistException_base: S.ErrorClass<CertificateDoesNotExistException, S.TaggedStruct<"CertificateDoesNotExistException", {
+declare const CertificateDoesNotExistException_base: S.Class<CertificateDoesNotExistException, S.TaggedStruct<"CertificateDoesNotExistException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CertificateDoesNotExistException extends CertificateDoesNotExistException_base {
 }
-declare const CertificateInUseException_base: S.ErrorClass<CertificateInUseException, S.TaggedStruct<"CertificateInUseException", {
+declare const CertificateInUseException_base: S.Class<CertificateInUseException, S.TaggedStruct<"CertificateInUseException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CertificateInUseException extends CertificateInUseException_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>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const DisableAlreadyInProgressException_base: S.ErrorClass<DisableAlreadyInProgressException, S.TaggedStruct<"DisableAlreadyInProgressException", {
+declare const DisableAlreadyInProgressException_base: S.Class<DisableAlreadyInProgressException, S.TaggedStruct<"DisableAlreadyInProgressException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DisableAlreadyInProgressException extends DisableAlreadyInProgressException_base {
 }
-declare const InvalidClientAuthStatusException_base: S.ErrorClass<InvalidClientAuthStatusException, S.TaggedStruct<"InvalidClientAuthStatusException", {
+declare const InvalidClientAuthStatusException_base: S.Class<InvalidClientAuthStatusException, S.TaggedStruct<"InvalidClientAuthStatusException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidClientAuthStatusException extends InvalidClientAuthStatusException_base {
 }
-declare const DirectoryInDesiredStateException_base: S.ErrorClass<DirectoryInDesiredStateException, S.TaggedStruct<"DirectoryInDesiredStateException", {
+declare const DirectoryInDesiredStateException_base: S.Class<DirectoryInDesiredStateException, S.TaggedStruct<"DirectoryInDesiredStateException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryInDesiredStateException extends DirectoryInDesiredStateException_base {
 }
-declare const InvalidLDAPSStatusException_base: S.ErrorClass<InvalidLDAPSStatusException, S.TaggedStruct<"InvalidLDAPSStatusException", {
+declare const InvalidLDAPSStatusException_base: S.Class<InvalidLDAPSStatusException, S.TaggedStruct<"InvalidLDAPSStatusException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLDAPSStatusException extends InvalidLDAPSStatusException_base {
 }
-declare const EnableAlreadyInProgressException_base: S.ErrorClass<EnableAlreadyInProgressException, S.TaggedStruct<"EnableAlreadyInProgressException", {
+declare const EnableAlreadyInProgressException_base: S.Class<EnableAlreadyInProgressException, S.TaggedStruct<"EnableAlreadyInProgressException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EnableAlreadyInProgressException extends EnableAlreadyInProgressException_base {
 }
-declare const NoAvailableCertificateException_base: S.ErrorClass<NoAvailableCertificateException, S.TaggedStruct<"NoAvailableCertificateException", {
+declare const NoAvailableCertificateException_base: S.Class<NoAvailableCertificateException, S.TaggedStruct<"NoAvailableCertificateException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoAvailableCertificateException extends NoAvailableCertificateException_base {
 }
-declare const CertificateAlreadyExistsException_base: S.ErrorClass<CertificateAlreadyExistsException, S.TaggedStruct<"CertificateAlreadyExistsException", {
+declare const CertificateAlreadyExistsException_base: S.Class<CertificateAlreadyExistsException, S.TaggedStruct<"CertificateAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1650,67 +1650,67 @@ declare const CertificateAlreadyExistsException_base: S.ErrorClass<CertificateAl
 });
 export declare class CertificateAlreadyExistsException extends CertificateAlreadyExistsException_base {
 }
-declare const CertificateLimitExceededException_base: S.ErrorClass<CertificateLimitExceededException, S.TaggedStruct<"CertificateLimitExceededException", {
+declare const CertificateLimitExceededException_base: S.Class<CertificateLimitExceededException, S.TaggedStruct<"CertificateLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CertificateLimitExceededException extends CertificateLimitExceededException_base {
 }
-declare const InvalidCertificateException_base: S.ErrorClass<InvalidCertificateException, S.TaggedStruct<"InvalidCertificateException", {
+declare const InvalidCertificateException_base: S.Class<InvalidCertificateException, S.TaggedStruct<"InvalidCertificateException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCertificateException extends InvalidCertificateException_base {
 }
-declare const InvalidPasswordException_base: S.ErrorClass<InvalidPasswordException, S.TaggedStruct<"InvalidPasswordException", {
+declare const InvalidPasswordException_base: S.Class<InvalidPasswordException, S.TaggedStruct<"InvalidPasswordException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPasswordException extends InvalidPasswordException_base {
 }
-declare const UserDoesNotExistException_base: S.ErrorClass<UserDoesNotExistException, S.TaggedStruct<"UserDoesNotExistException", {
+declare const UserDoesNotExistException_base: S.Class<UserDoesNotExistException, S.TaggedStruct<"UserDoesNotExistException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UserDoesNotExistException extends UserDoesNotExistException_base {
 }
-declare const InvalidTargetException_base: S.ErrorClass<InvalidTargetException, S.TaggedStruct<"InvalidTargetException", {
+declare const InvalidTargetException_base: S.Class<InvalidTargetException, S.TaggedStruct<"InvalidTargetException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetException extends InvalidTargetException_base {
 }
-declare const OrganizationsException_base: S.ErrorClass<OrganizationsException, S.TaggedStruct<"OrganizationsException", {
+declare const OrganizationsException_base: S.Class<OrganizationsException, S.TaggedStruct<"OrganizationsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OrganizationsException extends OrganizationsException_base {
 }
-declare const ShareLimitExceededException_base: S.ErrorClass<ShareLimitExceededException, S.TaggedStruct<"ShareLimitExceededException", {
+declare const ShareLimitExceededException_base: S.Class<ShareLimitExceededException, S.TaggedStruct<"ShareLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ShareLimitExceededException extends ShareLimitExceededException_base {
 }
-declare const DirectoryNotSharedException_base: S.ErrorClass<DirectoryNotSharedException, S.TaggedStruct<"DirectoryNotSharedException", {
+declare const DirectoryNotSharedException_base: S.Class<DirectoryNotSharedException, S.TaggedStruct<"DirectoryNotSharedException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryNotSharedException extends DirectoryNotSharedException_base {
 }
-declare const DomainControllerLimitExceededException_base: S.ErrorClass<DomainControllerLimitExceededException, S.TaggedStruct<"DomainControllerLimitExceededException", {
+declare const DomainControllerLimitExceededException_base: S.Class<DomainControllerLimitExceededException, S.TaggedStruct<"DomainControllerLimitExceededException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DomainControllerLimitExceededException extends DomainControllerLimitExceededException_base {
 }
-declare const IncompatibleSettingsException_base: S.ErrorClass<IncompatibleSettingsException, S.TaggedStruct<"IncompatibleSettingsException", {
+declare const IncompatibleSettingsException_base: S.Class<IncompatibleSettingsException, S.TaggedStruct<"IncompatibleSettingsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IncompatibleSettingsException extends IncompatibleSettingsException_base {
 }
-declare const UnsupportedSettingsException_base: S.ErrorClass<UnsupportedSettingsException, S.TaggedStruct<"UnsupportedSettingsException", {
+declare const UnsupportedSettingsException_base: S.Class<UnsupportedSettingsException, S.TaggedStruct<"UnsupportedSettingsException", {
     readonly Message: S.optional<S.String>;
     readonly RequestId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/dlm.d.ts

@@ -473,7 +473,7 @@ export declare const UpdateLifecyclePolicyRequest: S.Schema<UpdateLifecyclePolic
 export interface UpdateLifecyclePolicyResponse {
 }
 export declare const UpdateLifecyclePolicyResponse: S.Schema<UpdateLifecyclePolicyResponse>;
-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>;
     readonly Code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -483,7 +483,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
+declare const InvalidRequestException_base: S.Class<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
     readonly Message: S.optional<S.String>;
     readonly Code: S.optional<S.String>;
     readonly RequiredParameters: S.optional<S.$Array<S.String>>;
@@ -495,7 +495,7 @@ declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException
 });
 export declare class InvalidRequestException extends InvalidRequestException_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>;
     readonly Code: S.optional<S.String>;
     readonly ResourceType: S.optional<S.String>;
@@ -506,7 +506,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>;
     readonly Code: S.optional<S.String>;
     readonly ResourceType: S.optional<S.String>;

package/lib/services/docdb-elastic.d.ts

@@ -323,7 +323,7 @@ export interface UpdateClusterOutput {
     cluster: Cluster;
 }
 export declare const UpdateClusterOutput: S.Schema<UpdateClusterOutput>;
-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": {
@@ -332,7 +332,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.String;
     readonly resourceId: S.String;
     readonly resourceType: S.String;
@@ -343,7 +343,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -356,7 +356,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.String;
     readonly resourceType: S.String;
@@ -367,7 +367,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 retryAfterSeconds: S.optional<S.Number>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -381,7 +381,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 reason: S.String;
     readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
@@ -392,7 +392,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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": {