@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/codedeploy.d.ts

@@ -1102,167 +1102,167 @@ export interface UpdateDeploymentGroupOutput {
     hooksNotCleanedUp?: AutoScalingGroup[];
 }
 export declare const UpdateDeploymentGroupOutput: S.Schema<UpdateDeploymentGroupOutput>;
-declare const InstanceLimitExceededException_base: S.ErrorClass<InstanceLimitExceededException, S.TaggedStruct<"InstanceLimitExceededException", {
+declare const InstanceLimitExceededException_base: S.Class<InstanceLimitExceededException, S.TaggedStruct<"InstanceLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceLimitExceededException extends InstanceLimitExceededException_base {
 }
-declare const InstanceNameRequiredException_base: S.ErrorClass<InstanceNameRequiredException, S.TaggedStruct<"InstanceNameRequiredException", {
+declare const InstanceNameRequiredException_base: S.Class<InstanceNameRequiredException, S.TaggedStruct<"InstanceNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceNameRequiredException extends InstanceNameRequiredException_base {
 }
-declare const InstanceNotRegisteredException_base: S.ErrorClass<InstanceNotRegisteredException, S.TaggedStruct<"InstanceNotRegisteredException", {
+declare const InstanceNotRegisteredException_base: S.Class<InstanceNotRegisteredException, S.TaggedStruct<"InstanceNotRegisteredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceNotRegisteredException extends InstanceNotRegisteredException_base {
 }
-declare const InvalidInstanceNameException_base: S.ErrorClass<InvalidInstanceNameException, S.TaggedStruct<"InvalidInstanceNameException", {
+declare const InvalidInstanceNameException_base: S.Class<InvalidInstanceNameException, S.TaggedStruct<"InvalidInstanceNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceNameException extends InvalidInstanceNameException_base {
 }
-declare const InvalidTagException_base: S.ErrorClass<InvalidTagException, S.TaggedStruct<"InvalidTagException", {
+declare const InvalidTagException_base: S.Class<InvalidTagException, S.TaggedStruct<"InvalidTagException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagException extends InvalidTagException_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>;
 export declare class TagLimitExceededException extends TagLimitExceededException_base {
 }
-declare const TagRequiredException_base: S.ErrorClass<TagRequiredException, S.TaggedStruct<"TagRequiredException", {
+declare const TagRequiredException_base: S.Class<TagRequiredException, S.TaggedStruct<"TagRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagRequiredException extends TagRequiredException_base {
 }
-declare const ApplicationDoesNotExistException_base: S.ErrorClass<ApplicationDoesNotExistException, S.TaggedStruct<"ApplicationDoesNotExistException", {
+declare const ApplicationDoesNotExistException_base: S.Class<ApplicationDoesNotExistException, S.TaggedStruct<"ApplicationDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApplicationDoesNotExistException extends ApplicationDoesNotExistException_base {
 }
-declare const ApplicationNameRequiredException_base: S.ErrorClass<ApplicationNameRequiredException, S.TaggedStruct<"ApplicationNameRequiredException", {
+declare const ApplicationNameRequiredException_base: S.Class<ApplicationNameRequiredException, S.TaggedStruct<"ApplicationNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApplicationNameRequiredException extends ApplicationNameRequiredException_base {
 }
-declare const BatchLimitExceededException_base: S.ErrorClass<BatchLimitExceededException, S.TaggedStruct<"BatchLimitExceededException", {
+declare const BatchLimitExceededException_base: S.Class<BatchLimitExceededException, S.TaggedStruct<"BatchLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BatchLimitExceededException extends BatchLimitExceededException_base {
 }
-declare const InvalidApplicationNameException_base: S.ErrorClass<InvalidApplicationNameException, S.TaggedStruct<"InvalidApplicationNameException", {
+declare const InvalidApplicationNameException_base: S.Class<InvalidApplicationNameException, S.TaggedStruct<"InvalidApplicationNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApplicationNameException extends InvalidApplicationNameException_base {
 }
-declare const InvalidRevisionException_base: S.ErrorClass<InvalidRevisionException, S.TaggedStruct<"InvalidRevisionException", {
+declare const InvalidRevisionException_base: S.Class<InvalidRevisionException, S.TaggedStruct<"InvalidRevisionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRevisionException extends InvalidRevisionException_base {
 }
-declare const RevisionRequiredException_base: S.ErrorClass<RevisionRequiredException, S.TaggedStruct<"RevisionRequiredException", {
+declare const RevisionRequiredException_base: S.Class<RevisionRequiredException, S.TaggedStruct<"RevisionRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RevisionRequiredException extends RevisionRequiredException_base {
 }
-declare const DeploymentConfigDoesNotExistException_base: S.ErrorClass<DeploymentConfigDoesNotExistException, S.TaggedStruct<"DeploymentConfigDoesNotExistException", {
+declare const DeploymentConfigDoesNotExistException_base: S.Class<DeploymentConfigDoesNotExistException, S.TaggedStruct<"DeploymentConfigDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentConfigDoesNotExistException extends DeploymentConfigDoesNotExistException_base {
 }
-declare const DeploymentGroupNameRequiredException_base: S.ErrorClass<DeploymentGroupNameRequiredException, S.TaggedStruct<"DeploymentGroupNameRequiredException", {
+declare const DeploymentGroupNameRequiredException_base: S.Class<DeploymentGroupNameRequiredException, S.TaggedStruct<"DeploymentGroupNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentGroupNameRequiredException extends DeploymentGroupNameRequiredException_base {
 }
-declare const InvalidDeploymentGroupNameException_base: S.ErrorClass<InvalidDeploymentGroupNameException, S.TaggedStruct<"InvalidDeploymentGroupNameException", {
+declare const InvalidDeploymentGroupNameException_base: S.Class<InvalidDeploymentGroupNameException, S.TaggedStruct<"InvalidDeploymentGroupNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentGroupNameException extends InvalidDeploymentGroupNameException_base {
 }
-declare const DeploymentDoesNotExistException_base: S.ErrorClass<DeploymentDoesNotExistException, S.TaggedStruct<"DeploymentDoesNotExistException", {
+declare const DeploymentDoesNotExistException_base: S.Class<DeploymentDoesNotExistException, S.TaggedStruct<"DeploymentDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentDoesNotExistException extends DeploymentDoesNotExistException_base {
 }
-declare const DeploymentIdRequiredException_base: S.ErrorClass<DeploymentIdRequiredException, S.TaggedStruct<"DeploymentIdRequiredException", {
+declare const DeploymentIdRequiredException_base: S.Class<DeploymentIdRequiredException, S.TaggedStruct<"DeploymentIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentIdRequiredException extends DeploymentIdRequiredException_base {
 }
-declare const InstanceIdRequiredException_base: S.ErrorClass<InstanceIdRequiredException, S.TaggedStruct<"InstanceIdRequiredException", {
+declare const InstanceIdRequiredException_base: S.Class<InstanceIdRequiredException, S.TaggedStruct<"InstanceIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceIdRequiredException extends InstanceIdRequiredException_base {
 }
-declare const InvalidComputePlatformException_base: S.ErrorClass<InvalidComputePlatformException, S.TaggedStruct<"InvalidComputePlatformException", {
+declare const InvalidComputePlatformException_base: S.Class<InvalidComputePlatformException, S.TaggedStruct<"InvalidComputePlatformException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidComputePlatformException extends InvalidComputePlatformException_base {
 }
-declare const InvalidDeploymentIdException_base: S.ErrorClass<InvalidDeploymentIdException, S.TaggedStruct<"InvalidDeploymentIdException", {
+declare const InvalidDeploymentIdException_base: S.Class<InvalidDeploymentIdException, S.TaggedStruct<"InvalidDeploymentIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentIdException extends InvalidDeploymentIdException_base {
 }
-declare const DeploymentNotStartedException_base: S.ErrorClass<DeploymentNotStartedException, S.TaggedStruct<"DeploymentNotStartedException", {
+declare const DeploymentNotStartedException_base: S.Class<DeploymentNotStartedException, S.TaggedStruct<"DeploymentNotStartedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentNotStartedException extends DeploymentNotStartedException_base {
 }
-declare const DeploymentTargetDoesNotExistException_base: S.ErrorClass<DeploymentTargetDoesNotExistException, S.TaggedStruct<"DeploymentTargetDoesNotExistException", {
+declare const DeploymentTargetDoesNotExistException_base: S.Class<DeploymentTargetDoesNotExistException, S.TaggedStruct<"DeploymentTargetDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentTargetDoesNotExistException extends DeploymentTargetDoesNotExistException_base {
 }
-declare const DeploymentTargetIdRequiredException_base: S.ErrorClass<DeploymentTargetIdRequiredException, S.TaggedStruct<"DeploymentTargetIdRequiredException", {
+declare const DeploymentTargetIdRequiredException_base: S.Class<DeploymentTargetIdRequiredException, S.TaggedStruct<"DeploymentTargetIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentTargetIdRequiredException extends DeploymentTargetIdRequiredException_base {
 }
-declare const DeploymentTargetListSizeExceededException_base: S.ErrorClass<DeploymentTargetListSizeExceededException, S.TaggedStruct<"DeploymentTargetListSizeExceededException", {
+declare const DeploymentTargetListSizeExceededException_base: S.Class<DeploymentTargetListSizeExceededException, S.TaggedStruct<"DeploymentTargetListSizeExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentTargetListSizeExceededException extends DeploymentTargetListSizeExceededException_base {
 }
-declare const InstanceDoesNotExistException_base: S.ErrorClass<InstanceDoesNotExistException, S.TaggedStruct<"InstanceDoesNotExistException", {
+declare const InstanceDoesNotExistException_base: S.Class<InstanceDoesNotExistException, S.TaggedStruct<"InstanceDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceDoesNotExistException extends InstanceDoesNotExistException_base {
 }
-declare const InvalidDeploymentTargetIdException_base: S.ErrorClass<InvalidDeploymentTargetIdException, S.TaggedStruct<"InvalidDeploymentTargetIdException", {
+declare const InvalidDeploymentTargetIdException_base: S.Class<InvalidDeploymentTargetIdException, S.TaggedStruct<"InvalidDeploymentTargetIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentTargetIdException extends InvalidDeploymentTargetIdException_base {
 }
-declare const DeploymentAlreadyCompletedException_base: S.ErrorClass<DeploymentAlreadyCompletedException, S.TaggedStruct<"DeploymentAlreadyCompletedException", {
+declare const DeploymentAlreadyCompletedException_base: S.Class<DeploymentAlreadyCompletedException, S.TaggedStruct<"DeploymentAlreadyCompletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentAlreadyCompletedException extends DeploymentAlreadyCompletedException_base {
 }
-declare const DeploymentIsNotInReadyStateException_base: S.ErrorClass<DeploymentIsNotInReadyStateException, S.TaggedStruct<"DeploymentIsNotInReadyStateException", {
+declare const DeploymentIsNotInReadyStateException_base: S.Class<DeploymentIsNotInReadyStateException, S.TaggedStruct<"DeploymentIsNotInReadyStateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentIsNotInReadyStateException extends DeploymentIsNotInReadyStateException_base {
 }
-declare const InvalidDeploymentStatusException_base: S.ErrorClass<InvalidDeploymentStatusException, S.TaggedStruct<"InvalidDeploymentStatusException", {
+declare const InvalidDeploymentStatusException_base: S.Class<InvalidDeploymentStatusException, S.TaggedStruct<"InvalidDeploymentStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentStatusException extends InvalidDeploymentStatusException_base {
 }
-declare const InvalidDeploymentWaitTypeException_base: S.ErrorClass<InvalidDeploymentWaitTypeException, S.TaggedStruct<"InvalidDeploymentWaitTypeException", {
+declare const InvalidDeploymentWaitTypeException_base: S.Class<InvalidDeploymentWaitTypeException, S.TaggedStruct<"InvalidDeploymentWaitTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentWaitTypeException extends InvalidDeploymentWaitTypeException_base {
 }
-declare const UnsupportedActionForDeploymentTypeException_base: S.ErrorClass<UnsupportedActionForDeploymentTypeException, S.TaggedStruct<"UnsupportedActionForDeploymentTypeException", {
+declare const UnsupportedActionForDeploymentTypeException_base: S.Class<UnsupportedActionForDeploymentTypeException, S.TaggedStruct<"UnsupportedActionForDeploymentTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedActionForDeploymentTypeException extends UnsupportedActionForDeploymentTypeException_base {
 }
-declare const ApplicationAlreadyExistsException_base: S.ErrorClass<ApplicationAlreadyExistsException, S.TaggedStruct<"ApplicationAlreadyExistsException", {
+declare const ApplicationAlreadyExistsException_base: S.Class<ApplicationAlreadyExistsException, S.TaggedStruct<"ApplicationAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1271,107 +1271,107 @@ declare const ApplicationAlreadyExistsException_base: S.ErrorClass<ApplicationAl
 });
 export declare class ApplicationAlreadyExistsException extends ApplicationAlreadyExistsException_base {
 }
-declare const ApplicationLimitExceededException_base: S.ErrorClass<ApplicationLimitExceededException, S.TaggedStruct<"ApplicationLimitExceededException", {
+declare const ApplicationLimitExceededException_base: S.Class<ApplicationLimitExceededException, S.TaggedStruct<"ApplicationLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApplicationLimitExceededException extends ApplicationLimitExceededException_base {
 }
-declare const InvalidTagsToAddException_base: S.ErrorClass<InvalidTagsToAddException, S.TaggedStruct<"InvalidTagsToAddException", {
+declare const InvalidTagsToAddException_base: S.Class<InvalidTagsToAddException, S.TaggedStruct<"InvalidTagsToAddException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagsToAddException extends InvalidTagsToAddException_base {
 }
-declare const AlarmsLimitExceededException_base: S.ErrorClass<AlarmsLimitExceededException, S.TaggedStruct<"AlarmsLimitExceededException", {
+declare const AlarmsLimitExceededException_base: S.Class<AlarmsLimitExceededException, S.TaggedStruct<"AlarmsLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AlarmsLimitExceededException extends AlarmsLimitExceededException_base {
 }
-declare const DeploymentGroupDoesNotExistException_base: S.ErrorClass<DeploymentGroupDoesNotExistException, S.TaggedStruct<"DeploymentGroupDoesNotExistException", {
+declare const DeploymentGroupDoesNotExistException_base: S.Class<DeploymentGroupDoesNotExistException, S.TaggedStruct<"DeploymentGroupDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentGroupDoesNotExistException extends DeploymentGroupDoesNotExistException_base {
 }
-declare const DeploymentLimitExceededException_base: S.ErrorClass<DeploymentLimitExceededException, S.TaggedStruct<"DeploymentLimitExceededException", {
+declare const DeploymentLimitExceededException_base: S.Class<DeploymentLimitExceededException, S.TaggedStruct<"DeploymentLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentLimitExceededException extends DeploymentLimitExceededException_base {
 }
-declare const DescriptionTooLongException_base: S.ErrorClass<DescriptionTooLongException, S.TaggedStruct<"DescriptionTooLongException", {
+declare const DescriptionTooLongException_base: S.Class<DescriptionTooLongException, S.TaggedStruct<"DescriptionTooLongException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DescriptionTooLongException extends DescriptionTooLongException_base {
 }
-declare const InvalidAlarmConfigException_base: S.ErrorClass<InvalidAlarmConfigException, S.TaggedStruct<"InvalidAlarmConfigException", {
+declare const InvalidAlarmConfigException_base: S.Class<InvalidAlarmConfigException, S.TaggedStruct<"InvalidAlarmConfigException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAlarmConfigException extends InvalidAlarmConfigException_base {
 }
-declare const InvalidAutoRollbackConfigException_base: S.ErrorClass<InvalidAutoRollbackConfigException, S.TaggedStruct<"InvalidAutoRollbackConfigException", {
+declare const InvalidAutoRollbackConfigException_base: S.Class<InvalidAutoRollbackConfigException, S.TaggedStruct<"InvalidAutoRollbackConfigException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAutoRollbackConfigException extends InvalidAutoRollbackConfigException_base {
 }
-declare const InvalidAutoScalingGroupException_base: S.ErrorClass<InvalidAutoScalingGroupException, S.TaggedStruct<"InvalidAutoScalingGroupException", {
+declare const InvalidAutoScalingGroupException_base: S.Class<InvalidAutoScalingGroupException, S.TaggedStruct<"InvalidAutoScalingGroupException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAutoScalingGroupException extends InvalidAutoScalingGroupException_base {
 }
-declare const InvalidDeploymentConfigNameException_base: S.ErrorClass<InvalidDeploymentConfigNameException, S.TaggedStruct<"InvalidDeploymentConfigNameException", {
+declare const InvalidDeploymentConfigNameException_base: S.Class<InvalidDeploymentConfigNameException, S.TaggedStruct<"InvalidDeploymentConfigNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentConfigNameException extends InvalidDeploymentConfigNameException_base {
 }
-declare const InvalidFileExistsBehaviorException_base: S.ErrorClass<InvalidFileExistsBehaviorException, S.TaggedStruct<"InvalidFileExistsBehaviorException", {
+declare const InvalidFileExistsBehaviorException_base: S.Class<InvalidFileExistsBehaviorException, S.TaggedStruct<"InvalidFileExistsBehaviorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFileExistsBehaviorException extends InvalidFileExistsBehaviorException_base {
 }
-declare const InvalidGitHubAccountTokenException_base: S.ErrorClass<InvalidGitHubAccountTokenException, S.TaggedStruct<"InvalidGitHubAccountTokenException", {
+declare const InvalidGitHubAccountTokenException_base: S.Class<InvalidGitHubAccountTokenException, S.TaggedStruct<"InvalidGitHubAccountTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidGitHubAccountTokenException extends InvalidGitHubAccountTokenException_base {
 }
-declare const InvalidIgnoreApplicationStopFailuresValueException_base: S.ErrorClass<InvalidIgnoreApplicationStopFailuresValueException, S.TaggedStruct<"InvalidIgnoreApplicationStopFailuresValueException", {
+declare const InvalidIgnoreApplicationStopFailuresValueException_base: S.Class<InvalidIgnoreApplicationStopFailuresValueException, S.TaggedStruct<"InvalidIgnoreApplicationStopFailuresValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidIgnoreApplicationStopFailuresValueException extends InvalidIgnoreApplicationStopFailuresValueException_base {
 }
-declare const InvalidLoadBalancerInfoException_base: S.ErrorClass<InvalidLoadBalancerInfoException, S.TaggedStruct<"InvalidLoadBalancerInfoException", {
+declare const InvalidLoadBalancerInfoException_base: S.Class<InvalidLoadBalancerInfoException, S.TaggedStruct<"InvalidLoadBalancerInfoException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLoadBalancerInfoException extends InvalidLoadBalancerInfoException_base {
 }
-declare const InvalidRoleException_base: S.ErrorClass<InvalidRoleException, S.TaggedStruct<"InvalidRoleException", {
+declare const InvalidRoleException_base: S.Class<InvalidRoleException, S.TaggedStruct<"InvalidRoleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoleException extends InvalidRoleException_base {
 }
-declare const InvalidTargetInstancesException_base: S.ErrorClass<InvalidTargetInstancesException, S.TaggedStruct<"InvalidTargetInstancesException", {
+declare const InvalidTargetInstancesException_base: S.Class<InvalidTargetInstancesException, S.TaggedStruct<"InvalidTargetInstancesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetInstancesException extends InvalidTargetInstancesException_base {
 }
-declare const InvalidTrafficRoutingConfigurationException_base: S.ErrorClass<InvalidTrafficRoutingConfigurationException, S.TaggedStruct<"InvalidTrafficRoutingConfigurationException", {
+declare const InvalidTrafficRoutingConfigurationException_base: S.Class<InvalidTrafficRoutingConfigurationException, S.TaggedStruct<"InvalidTrafficRoutingConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTrafficRoutingConfigurationException extends InvalidTrafficRoutingConfigurationException_base {
 }
-declare const InvalidUpdateOutdatedInstancesOnlyValueException_base: S.ErrorClass<InvalidUpdateOutdatedInstancesOnlyValueException, S.TaggedStruct<"InvalidUpdateOutdatedInstancesOnlyValueException", {
+declare const InvalidUpdateOutdatedInstancesOnlyValueException_base: S.Class<InvalidUpdateOutdatedInstancesOnlyValueException, S.TaggedStruct<"InvalidUpdateOutdatedInstancesOnlyValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidUpdateOutdatedInstancesOnlyValueException extends InvalidUpdateOutdatedInstancesOnlyValueException_base {
 }
-declare const RevisionDoesNotExistException_base: S.ErrorClass<RevisionDoesNotExistException, S.TaggedStruct<"RevisionDoesNotExistException", {
+declare const RevisionDoesNotExistException_base: S.Class<RevisionDoesNotExistException, S.TaggedStruct<"RevisionDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RevisionDoesNotExistException extends RevisionDoesNotExistException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const DeploymentConfigAlreadyExistsException_base: S.ErrorClass<DeploymentConfigAlreadyExistsException, S.TaggedStruct<"DeploymentConfigAlreadyExistsException", {
+declare const DeploymentConfigAlreadyExistsException_base: S.Class<DeploymentConfigAlreadyExistsException, S.TaggedStruct<"DeploymentConfigAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1380,27 +1380,27 @@ declare const DeploymentConfigAlreadyExistsException_base: S.ErrorClass<Deployme
 });
 export declare class DeploymentConfigAlreadyExistsException extends DeploymentConfigAlreadyExistsException_base {
 }
-declare const DeploymentConfigLimitExceededException_base: S.ErrorClass<DeploymentConfigLimitExceededException, S.TaggedStruct<"DeploymentConfigLimitExceededException", {
+declare const DeploymentConfigLimitExceededException_base: S.Class<DeploymentConfigLimitExceededException, S.TaggedStruct<"DeploymentConfigLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentConfigLimitExceededException extends DeploymentConfigLimitExceededException_base {
 }
-declare const DeploymentConfigNameRequiredException_base: S.ErrorClass<DeploymentConfigNameRequiredException, S.TaggedStruct<"DeploymentConfigNameRequiredException", {
+declare const DeploymentConfigNameRequiredException_base: S.Class<DeploymentConfigNameRequiredException, S.TaggedStruct<"DeploymentConfigNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentConfigNameRequiredException extends DeploymentConfigNameRequiredException_base {
 }
-declare const InvalidMinimumHealthyHostValueException_base: S.ErrorClass<InvalidMinimumHealthyHostValueException, S.TaggedStruct<"InvalidMinimumHealthyHostValueException", {
+declare const InvalidMinimumHealthyHostValueException_base: S.Class<InvalidMinimumHealthyHostValueException, S.TaggedStruct<"InvalidMinimumHealthyHostValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMinimumHealthyHostValueException extends InvalidMinimumHealthyHostValueException_base {
 }
-declare const InvalidZonalDeploymentConfigurationException_base: S.ErrorClass<InvalidZonalDeploymentConfigurationException, S.TaggedStruct<"InvalidZonalDeploymentConfigurationException", {
+declare const InvalidZonalDeploymentConfigurationException_base: S.Class<InvalidZonalDeploymentConfigurationException, S.TaggedStruct<"InvalidZonalDeploymentConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidZonalDeploymentConfigurationException extends InvalidZonalDeploymentConfigurationException_base {
 }
-declare const DeploymentGroupAlreadyExistsException_base: S.ErrorClass<DeploymentGroupAlreadyExistsException, S.TaggedStruct<"DeploymentGroupAlreadyExistsException", {
+declare const DeploymentGroupAlreadyExistsException_base: S.Class<DeploymentGroupAlreadyExistsException, S.TaggedStruct<"DeploymentGroupAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1409,257 +1409,257 @@ declare const DeploymentGroupAlreadyExistsException_base: S.ErrorClass<Deploymen
 });
 export declare class DeploymentGroupAlreadyExistsException extends DeploymentGroupAlreadyExistsException_base {
 }
-declare const DeploymentGroupLimitExceededException_base: S.ErrorClass<DeploymentGroupLimitExceededException, S.TaggedStruct<"DeploymentGroupLimitExceededException", {
+declare const DeploymentGroupLimitExceededException_base: S.Class<DeploymentGroupLimitExceededException, S.TaggedStruct<"DeploymentGroupLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentGroupLimitExceededException extends DeploymentGroupLimitExceededException_base {
 }
-declare const ECSServiceMappingLimitExceededException_base: S.ErrorClass<ECSServiceMappingLimitExceededException, S.TaggedStruct<"ECSServiceMappingLimitExceededException", {
+declare const ECSServiceMappingLimitExceededException_base: S.Class<ECSServiceMappingLimitExceededException, S.TaggedStruct<"ECSServiceMappingLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ECSServiceMappingLimitExceededException extends ECSServiceMappingLimitExceededException_base {
 }
-declare const InvalidBlueGreenDeploymentConfigurationException_base: S.ErrorClass<InvalidBlueGreenDeploymentConfigurationException, S.TaggedStruct<"InvalidBlueGreenDeploymentConfigurationException", {
+declare const InvalidBlueGreenDeploymentConfigurationException_base: S.Class<InvalidBlueGreenDeploymentConfigurationException, S.TaggedStruct<"InvalidBlueGreenDeploymentConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBlueGreenDeploymentConfigurationException extends InvalidBlueGreenDeploymentConfigurationException_base {
 }
-declare const InvalidDeploymentStyleException_base: S.ErrorClass<InvalidDeploymentStyleException, S.TaggedStruct<"InvalidDeploymentStyleException", {
+declare const InvalidDeploymentStyleException_base: S.Class<InvalidDeploymentStyleException, S.TaggedStruct<"InvalidDeploymentStyleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentStyleException extends InvalidDeploymentStyleException_base {
 }
-declare const InvalidEC2TagCombinationException_base: S.ErrorClass<InvalidEC2TagCombinationException, S.TaggedStruct<"InvalidEC2TagCombinationException", {
+declare const InvalidEC2TagCombinationException_base: S.Class<InvalidEC2TagCombinationException, S.TaggedStruct<"InvalidEC2TagCombinationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidEC2TagCombinationException extends InvalidEC2TagCombinationException_base {
 }
-declare const InvalidEC2TagException_base: S.ErrorClass<InvalidEC2TagException, S.TaggedStruct<"InvalidEC2TagException", {
+declare const InvalidEC2TagException_base: S.Class<InvalidEC2TagException, S.TaggedStruct<"InvalidEC2TagException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidEC2TagException extends InvalidEC2TagException_base {
 }
-declare const InvalidECSServiceException_base: S.ErrorClass<InvalidECSServiceException, S.TaggedStruct<"InvalidECSServiceException", {
+declare const InvalidECSServiceException_base: S.Class<InvalidECSServiceException, S.TaggedStruct<"InvalidECSServiceException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidECSServiceException extends InvalidECSServiceException_base {
 }
-declare const InvalidInputException_base: S.ErrorClass<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
+declare const InvalidInputException_base: S.Class<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInputException extends InvalidInputException_base {
 }
-declare const InvalidOnPremisesTagCombinationException_base: S.ErrorClass<InvalidOnPremisesTagCombinationException, S.TaggedStruct<"InvalidOnPremisesTagCombinationException", {
+declare const InvalidOnPremisesTagCombinationException_base: S.Class<InvalidOnPremisesTagCombinationException, S.TaggedStruct<"InvalidOnPremisesTagCombinationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOnPremisesTagCombinationException extends InvalidOnPremisesTagCombinationException_base {
 }
-declare const InvalidTargetGroupPairException_base: S.ErrorClass<InvalidTargetGroupPairException, S.TaggedStruct<"InvalidTargetGroupPairException", {
+declare const InvalidTargetGroupPairException_base: S.Class<InvalidTargetGroupPairException, S.TaggedStruct<"InvalidTargetGroupPairException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetGroupPairException extends InvalidTargetGroupPairException_base {
 }
-declare const InvalidTriggerConfigException_base: S.ErrorClass<InvalidTriggerConfigException, S.TaggedStruct<"InvalidTriggerConfigException", {
+declare const InvalidTriggerConfigException_base: S.Class<InvalidTriggerConfigException, S.TaggedStruct<"InvalidTriggerConfigException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTriggerConfigException extends InvalidTriggerConfigException_base {
 }
-declare const LifecycleHookLimitExceededException_base: S.ErrorClass<LifecycleHookLimitExceededException, S.TaggedStruct<"LifecycleHookLimitExceededException", {
+declare const LifecycleHookLimitExceededException_base: S.Class<LifecycleHookLimitExceededException, S.TaggedStruct<"LifecycleHookLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LifecycleHookLimitExceededException extends LifecycleHookLimitExceededException_base {
 }
-declare const RoleRequiredException_base: S.ErrorClass<RoleRequiredException, S.TaggedStruct<"RoleRequiredException", {
+declare const RoleRequiredException_base: S.Class<RoleRequiredException, S.TaggedStruct<"RoleRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RoleRequiredException extends RoleRequiredException_base {
 }
-declare const TagSetListLimitExceededException_base: S.ErrorClass<TagSetListLimitExceededException, S.TaggedStruct<"TagSetListLimitExceededException", {
+declare const TagSetListLimitExceededException_base: S.Class<TagSetListLimitExceededException, S.TaggedStruct<"TagSetListLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagSetListLimitExceededException extends TagSetListLimitExceededException_base {
 }
-declare const TriggerTargetsLimitExceededException_base: S.ErrorClass<TriggerTargetsLimitExceededException, S.TaggedStruct<"TriggerTargetsLimitExceededException", {
+declare const TriggerTargetsLimitExceededException_base: S.Class<TriggerTargetsLimitExceededException, S.TaggedStruct<"TriggerTargetsLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TriggerTargetsLimitExceededException extends TriggerTargetsLimitExceededException_base {
 }
-declare const DeploymentConfigInUseException_base: S.ErrorClass<DeploymentConfigInUseException, S.TaggedStruct<"DeploymentConfigInUseException", {
+declare const DeploymentConfigInUseException_base: S.Class<DeploymentConfigInUseException, S.TaggedStruct<"DeploymentConfigInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DeploymentConfigInUseException extends DeploymentConfigInUseException_base {
 }
-declare const InvalidOperationException_base: S.ErrorClass<InvalidOperationException, S.TaggedStruct<"InvalidOperationException", {
+declare const InvalidOperationException_base: S.Class<InvalidOperationException, S.TaggedStruct<"InvalidOperationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOperationException extends InvalidOperationException_base {
 }
-declare const GitHubAccountTokenDoesNotExistException_base: S.ErrorClass<GitHubAccountTokenDoesNotExistException, S.TaggedStruct<"GitHubAccountTokenDoesNotExistException", {
+declare const GitHubAccountTokenDoesNotExistException_base: S.Class<GitHubAccountTokenDoesNotExistException, S.TaggedStruct<"GitHubAccountTokenDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class GitHubAccountTokenDoesNotExistException extends GitHubAccountTokenDoesNotExistException_base {
 }
-declare const GitHubAccountTokenNameRequiredException_base: S.ErrorClass<GitHubAccountTokenNameRequiredException, S.TaggedStruct<"GitHubAccountTokenNameRequiredException", {
+declare const GitHubAccountTokenNameRequiredException_base: S.Class<GitHubAccountTokenNameRequiredException, S.TaggedStruct<"GitHubAccountTokenNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class GitHubAccountTokenNameRequiredException extends GitHubAccountTokenNameRequiredException_base {
 }
-declare const InvalidGitHubAccountTokenNameException_base: S.ErrorClass<InvalidGitHubAccountTokenNameException, S.TaggedStruct<"InvalidGitHubAccountTokenNameException", {
+declare const InvalidGitHubAccountTokenNameException_base: S.Class<InvalidGitHubAccountTokenNameException, S.TaggedStruct<"InvalidGitHubAccountTokenNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidGitHubAccountTokenNameException extends InvalidGitHubAccountTokenNameException_base {
 }
-declare const OperationNotSupportedException_base: S.ErrorClass<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
+declare const OperationNotSupportedException_base: S.Class<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationNotSupportedException extends OperationNotSupportedException_base {
 }
-declare const ResourceValidationException_base: S.ErrorClass<ResourceValidationException, S.TaggedStruct<"ResourceValidationException", {
+declare const ResourceValidationException_base: S.Class<ResourceValidationException, S.TaggedStruct<"ResourceValidationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceValidationException extends ResourceValidationException_base {
 }
-declare const BucketNameFilterRequiredException_base: S.ErrorClass<BucketNameFilterRequiredException, S.TaggedStruct<"BucketNameFilterRequiredException", {
+declare const BucketNameFilterRequiredException_base: S.Class<BucketNameFilterRequiredException, S.TaggedStruct<"BucketNameFilterRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BucketNameFilterRequiredException extends BucketNameFilterRequiredException_base {
 }
-declare const InvalidBucketNameFilterException_base: S.ErrorClass<InvalidBucketNameFilterException, S.TaggedStruct<"InvalidBucketNameFilterException", {
+declare const InvalidBucketNameFilterException_base: S.Class<InvalidBucketNameFilterException, S.TaggedStruct<"InvalidBucketNameFilterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBucketNameFilterException extends InvalidBucketNameFilterException_base {
 }
-declare const InvalidDeployedStateFilterException_base: S.ErrorClass<InvalidDeployedStateFilterException, S.TaggedStruct<"InvalidDeployedStateFilterException", {
+declare const InvalidDeployedStateFilterException_base: S.Class<InvalidDeployedStateFilterException, S.TaggedStruct<"InvalidDeployedStateFilterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeployedStateFilterException extends InvalidDeployedStateFilterException_base {
 }
-declare const InvalidKeyPrefixFilterException_base: S.ErrorClass<InvalidKeyPrefixFilterException, S.TaggedStruct<"InvalidKeyPrefixFilterException", {
+declare const InvalidKeyPrefixFilterException_base: S.Class<InvalidKeyPrefixFilterException, S.TaggedStruct<"InvalidKeyPrefixFilterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidKeyPrefixFilterException extends InvalidKeyPrefixFilterException_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 {
 }
-declare const InvalidSortByException_base: S.ErrorClass<InvalidSortByException, S.TaggedStruct<"InvalidSortByException", {
+declare const InvalidSortByException_base: S.Class<InvalidSortByException, S.TaggedStruct<"InvalidSortByException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSortByException extends InvalidSortByException_base {
 }
-declare const InvalidSortOrderException_base: S.ErrorClass<InvalidSortOrderException, S.TaggedStruct<"InvalidSortOrderException", {
+declare const InvalidSortOrderException_base: S.Class<InvalidSortOrderException, S.TaggedStruct<"InvalidSortOrderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSortOrderException extends InvalidSortOrderException_base {
 }
-declare const InvalidDeploymentInstanceTypeException_base: S.ErrorClass<InvalidDeploymentInstanceTypeException, S.TaggedStruct<"InvalidDeploymentInstanceTypeException", {
+declare const InvalidDeploymentInstanceTypeException_base: S.Class<InvalidDeploymentInstanceTypeException, S.TaggedStruct<"InvalidDeploymentInstanceTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeploymentInstanceTypeException extends InvalidDeploymentInstanceTypeException_base {
 }
-declare const InvalidInstanceStatusException_base: S.ErrorClass<InvalidInstanceStatusException, S.TaggedStruct<"InvalidInstanceStatusException", {
+declare const InvalidInstanceStatusException_base: S.Class<InvalidInstanceStatusException, S.TaggedStruct<"InvalidInstanceStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceStatusException extends InvalidInstanceStatusException_base {
 }
-declare const InvalidInstanceTypeException_base: S.ErrorClass<InvalidInstanceTypeException, S.TaggedStruct<"InvalidInstanceTypeException", {
+declare const InvalidInstanceTypeException_base: S.Class<InvalidInstanceTypeException, S.TaggedStruct<"InvalidInstanceTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceTypeException extends InvalidInstanceTypeException_base {
 }
-declare const InvalidTargetFilterNameException_base: S.ErrorClass<InvalidTargetFilterNameException, S.TaggedStruct<"InvalidTargetFilterNameException", {
+declare const InvalidTargetFilterNameException_base: S.Class<InvalidTargetFilterNameException, S.TaggedStruct<"InvalidTargetFilterNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetFilterNameException extends InvalidTargetFilterNameException_base {
 }
-declare const InvalidExternalIdException_base: S.ErrorClass<InvalidExternalIdException, S.TaggedStruct<"InvalidExternalIdException", {
+declare const InvalidExternalIdException_base: S.Class<InvalidExternalIdException, S.TaggedStruct<"InvalidExternalIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExternalIdException extends InvalidExternalIdException_base {
 }
-declare const InvalidTimeRangeException_base: S.ErrorClass<InvalidTimeRangeException, S.TaggedStruct<"InvalidTimeRangeException", {
+declare const InvalidTimeRangeException_base: S.Class<InvalidTimeRangeException, S.TaggedStruct<"InvalidTimeRangeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTimeRangeException extends InvalidTimeRangeException_base {
 }
-declare const InvalidRegistrationStatusException_base: S.ErrorClass<InvalidRegistrationStatusException, S.TaggedStruct<"InvalidRegistrationStatusException", {
+declare const InvalidRegistrationStatusException_base: S.Class<InvalidRegistrationStatusException, S.TaggedStruct<"InvalidRegistrationStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRegistrationStatusException extends InvalidRegistrationStatusException_base {
 }
-declare const InvalidTagFilterException_base: S.ErrorClass<InvalidTagFilterException, S.TaggedStruct<"InvalidTagFilterException", {
+declare const InvalidTagFilterException_base: S.Class<InvalidTagFilterException, S.TaggedStruct<"InvalidTagFilterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagFilterException extends InvalidTagFilterException_base {
 }
-declare const ArnNotSupportedException_base: S.ErrorClass<ArnNotSupportedException, S.TaggedStruct<"ArnNotSupportedException", {
+declare const ArnNotSupportedException_base: S.Class<ArnNotSupportedException, S.TaggedStruct<"ArnNotSupportedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ArnNotSupportedException extends ArnNotSupportedException_base {
 }
-declare const InvalidArnException_base: S.ErrorClass<InvalidArnException, S.TaggedStruct<"InvalidArnException", {
+declare const InvalidArnException_base: S.Class<InvalidArnException, S.TaggedStruct<"InvalidArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidArnException extends InvalidArnException_base {
 }
-declare const ResourceArnRequiredException_base: S.ErrorClass<ResourceArnRequiredException, S.TaggedStruct<"ResourceArnRequiredException", {
+declare const ResourceArnRequiredException_base: S.Class<ResourceArnRequiredException, S.TaggedStruct<"ResourceArnRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceArnRequiredException extends ResourceArnRequiredException_base {
 }
-declare const InvalidLifecycleEventHookExecutionIdException_base: S.ErrorClass<InvalidLifecycleEventHookExecutionIdException, S.TaggedStruct<"InvalidLifecycleEventHookExecutionIdException", {
+declare const InvalidLifecycleEventHookExecutionIdException_base: S.Class<InvalidLifecycleEventHookExecutionIdException, S.TaggedStruct<"InvalidLifecycleEventHookExecutionIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLifecycleEventHookExecutionIdException extends InvalidLifecycleEventHookExecutionIdException_base {
 }
-declare const InvalidLifecycleEventHookExecutionStatusException_base: S.ErrorClass<InvalidLifecycleEventHookExecutionStatusException, S.TaggedStruct<"InvalidLifecycleEventHookExecutionStatusException", {
+declare const InvalidLifecycleEventHookExecutionStatusException_base: S.Class<InvalidLifecycleEventHookExecutionStatusException, S.TaggedStruct<"InvalidLifecycleEventHookExecutionStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLifecycleEventHookExecutionStatusException extends InvalidLifecycleEventHookExecutionStatusException_base {
 }
-declare const LifecycleEventAlreadyCompletedException_base: S.ErrorClass<LifecycleEventAlreadyCompletedException, S.TaggedStruct<"LifecycleEventAlreadyCompletedException", {
+declare const LifecycleEventAlreadyCompletedException_base: S.Class<LifecycleEventAlreadyCompletedException, S.TaggedStruct<"LifecycleEventAlreadyCompletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LifecycleEventAlreadyCompletedException extends LifecycleEventAlreadyCompletedException_base {
 }
-declare const IamArnRequiredException_base: S.ErrorClass<IamArnRequiredException, S.TaggedStruct<"IamArnRequiredException", {
+declare const IamArnRequiredException_base: S.Class<IamArnRequiredException, S.TaggedStruct<"IamArnRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IamArnRequiredException extends IamArnRequiredException_base {
 }
-declare const IamSessionArnAlreadyRegisteredException_base: S.ErrorClass<IamSessionArnAlreadyRegisteredException, S.TaggedStruct<"IamSessionArnAlreadyRegisteredException", {
+declare const IamSessionArnAlreadyRegisteredException_base: S.Class<IamSessionArnAlreadyRegisteredException, S.TaggedStruct<"IamSessionArnAlreadyRegisteredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IamSessionArnAlreadyRegisteredException extends IamSessionArnAlreadyRegisteredException_base {
 }
-declare const IamUserArnAlreadyRegisteredException_base: S.ErrorClass<IamUserArnAlreadyRegisteredException, S.TaggedStruct<"IamUserArnAlreadyRegisteredException", {
+declare const IamUserArnAlreadyRegisteredException_base: S.Class<IamUserArnAlreadyRegisteredException, S.TaggedStruct<"IamUserArnAlreadyRegisteredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IamUserArnAlreadyRegisteredException extends IamUserArnAlreadyRegisteredException_base {
 }
-declare const IamUserArnRequiredException_base: S.ErrorClass<IamUserArnRequiredException, S.TaggedStruct<"IamUserArnRequiredException", {
+declare const IamUserArnRequiredException_base: S.Class<IamUserArnRequiredException, S.TaggedStruct<"IamUserArnRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IamUserArnRequiredException extends IamUserArnRequiredException_base {
 }
-declare const InstanceNameAlreadyRegisteredException_base: S.ErrorClass<InstanceNameAlreadyRegisteredException, S.TaggedStruct<"InstanceNameAlreadyRegisteredException", {
+declare const InstanceNameAlreadyRegisteredException_base: S.Class<InstanceNameAlreadyRegisteredException, S.TaggedStruct<"InstanceNameAlreadyRegisteredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InstanceNameAlreadyRegisteredException extends InstanceNameAlreadyRegisteredException_base {
 }
-declare const InvalidIamSessionArnException_base: S.ErrorClass<InvalidIamSessionArnException, S.TaggedStruct<"InvalidIamSessionArnException", {
+declare const InvalidIamSessionArnException_base: S.Class<InvalidIamSessionArnException, S.TaggedStruct<"InvalidIamSessionArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidIamSessionArnException extends InvalidIamSessionArnException_base {
 }
-declare const InvalidIamUserArnException_base: S.ErrorClass<InvalidIamUserArnException, S.TaggedStruct<"InvalidIamUserArnException", {
+declare const InvalidIamUserArnException_base: S.Class<InvalidIamUserArnException, S.TaggedStruct<"InvalidIamUserArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidIamUserArnException extends InvalidIamUserArnException_base {
 }
-declare const MultipleIamArnsProvidedException_base: S.ErrorClass<MultipleIamArnsProvidedException, S.TaggedStruct<"MultipleIamArnsProvidedException", {
+declare const MultipleIamArnsProvidedException_base: S.Class<MultipleIamArnsProvidedException, S.TaggedStruct<"MultipleIamArnsProvidedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MultipleIamArnsProvidedException extends MultipleIamArnsProvidedException_base {