@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/ecs.d.ts

@@ -2568,77 +2568,77 @@ export interface DescribeTaskSetsResponse {
     failures?: Failure[];
 }
 export declare const DescribeTaskSetsResponse: S.Schema<DescribeTaskSetsResponse>;
-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>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClientException extends ClientException_base {
 }
-declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
+declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterException extends InvalidParameterException_base {
 }
-declare const ServerException_base: S.ErrorClass<ServerException, S.TaggedStruct<"ServerException", {
+declare const ServerException_base: S.Class<ServerException, S.TaggedStruct<"ServerException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServerException extends ServerException_base {
 }
-declare const NamespaceNotFoundException_base: S.ErrorClass<NamespaceNotFoundException, S.TaggedStruct<"NamespaceNotFoundException", {
+declare const NamespaceNotFoundException_base: S.Class<NamespaceNotFoundException, S.TaggedStruct<"NamespaceNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NamespaceNotFoundException extends NamespaceNotFoundException_base {
 }
-declare const ClusterNotFoundException_base: S.ErrorClass<ClusterNotFoundException, S.TaggedStruct<"ClusterNotFoundException", {
+declare const ClusterNotFoundException_base: S.Class<ClusterNotFoundException, S.TaggedStruct<"ClusterNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterNotFoundException extends ClusterNotFoundException_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>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const UnsupportedFeatureException_base: S.ErrorClass<UnsupportedFeatureException, S.TaggedStruct<"UnsupportedFeatureException", {
+declare const UnsupportedFeatureException_base: S.Class<UnsupportedFeatureException, S.TaggedStruct<"UnsupportedFeatureException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedFeatureException extends UnsupportedFeatureException_base {
 }
-declare const UpdateInProgressException_base: S.ErrorClass<UpdateInProgressException, S.TaggedStruct<"UpdateInProgressException", {
+declare const UpdateInProgressException_base: S.Class<UpdateInProgressException, S.TaggedStruct<"UpdateInProgressException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UpdateInProgressException extends UpdateInProgressException_base {
 }
-declare const ClusterContainsCapacityProviderException_base: S.ErrorClass<ClusterContainsCapacityProviderException, S.TaggedStruct<"ClusterContainsCapacityProviderException", {
+declare const ClusterContainsCapacityProviderException_base: S.Class<ClusterContainsCapacityProviderException, S.TaggedStruct<"ClusterContainsCapacityProviderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterContainsCapacityProviderException extends ClusterContainsCapacityProviderException_base {
 }
-declare const ClusterContainsContainerInstancesException_base: S.ErrorClass<ClusterContainsContainerInstancesException, S.TaggedStruct<"ClusterContainsContainerInstancesException", {
+declare const ClusterContainsContainerInstancesException_base: S.Class<ClusterContainsContainerInstancesException, S.TaggedStruct<"ClusterContainsContainerInstancesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterContainsContainerInstancesException extends ClusterContainsContainerInstancesException_base {
 }
-declare const ClusterContainsServicesException_base: S.ErrorClass<ClusterContainsServicesException, S.TaggedStruct<"ClusterContainsServicesException", {
+declare const ClusterContainsServicesException_base: S.Class<ClusterContainsServicesException, S.TaggedStruct<"ClusterContainsServicesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterContainsServicesException extends ClusterContainsServicesException_base {
 }
-declare const ClusterContainsTasksException_base: S.ErrorClass<ClusterContainsTasksException, S.TaggedStruct<"ClusterContainsTasksException", {
+declare const ClusterContainsTasksException_base: S.Class<ClusterContainsTasksException, S.TaggedStruct<"ClusterContainsTasksException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClusterContainsTasksException extends ClusterContainsTasksException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2647,68 +2647,68 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const TargetNotConnectedException_base: S.ErrorClass<TargetNotConnectedException, S.TaggedStruct<"TargetNotConnectedException", {
+declare const TargetNotConnectedException_base: S.Class<TargetNotConnectedException, S.TaggedStruct<"TargetNotConnectedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetNotConnectedException extends TargetNotConnectedException_base {
 }
-declare const TargetNotFoundException_base: S.ErrorClass<TargetNotFoundException, S.TaggedStruct<"TargetNotFoundException", {
+declare const TargetNotFoundException_base: S.Class<TargetNotFoundException, S.TaggedStruct<"TargetNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetNotFoundException extends TargetNotFoundException_base {
 }
-declare const ServiceNotFoundException_base: S.ErrorClass<ServiceNotFoundException, S.TaggedStruct<"ServiceNotFoundException", {
+declare const ServiceNotFoundException_base: S.Class<ServiceNotFoundException, S.TaggedStruct<"ServiceNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceNotFoundException extends ServiceNotFoundException_base {
 }
-declare const AttributeLimitExceededException_base: S.ErrorClass<AttributeLimitExceededException, S.TaggedStruct<"AttributeLimitExceededException", {
+declare const AttributeLimitExceededException_base: S.Class<AttributeLimitExceededException, S.TaggedStruct<"AttributeLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AttributeLimitExceededException extends AttributeLimitExceededException_base {
 }
-declare const MissingVersionException_base: S.ErrorClass<MissingVersionException, S.TaggedStruct<"MissingVersionException", {
+declare const MissingVersionException_base: S.Class<MissingVersionException, S.TaggedStruct<"MissingVersionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MissingVersionException extends MissingVersionException_base {
 }
-declare const NoUpdateAvailableException_base: S.ErrorClass<NoUpdateAvailableException, S.TaggedStruct<"NoUpdateAvailableException", {
+declare const NoUpdateAvailableException_base: S.Class<NoUpdateAvailableException, S.TaggedStruct<"NoUpdateAvailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoUpdateAvailableException extends NoUpdateAvailableException_base {
 }
-declare const ServiceNotActiveException_base: S.ErrorClass<ServiceNotActiveException, S.TaggedStruct<"ServiceNotActiveException", {
+declare const ServiceNotActiveException_base: S.Class<ServiceNotActiveException, S.TaggedStruct<"ServiceNotActiveException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceNotActiveException extends ServiceNotActiveException_base {
 }
-declare const TaskSetNotFoundException_base: S.ErrorClass<TaskSetNotFoundException, S.TaggedStruct<"TaskSetNotFoundException", {
+declare const TaskSetNotFoundException_base: S.Class<TaskSetNotFoundException, S.TaggedStruct<"TaskSetNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TaskSetNotFoundException extends TaskSetNotFoundException_base {
 }
-declare const PlatformTaskDefinitionIncompatibilityException_base: S.ErrorClass<PlatformTaskDefinitionIncompatibilityException, S.TaggedStruct<"PlatformTaskDefinitionIncompatibilityException", {
+declare const PlatformTaskDefinitionIncompatibilityException_base: S.Class<PlatformTaskDefinitionIncompatibilityException, S.TaggedStruct<"PlatformTaskDefinitionIncompatibilityException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PlatformTaskDefinitionIncompatibilityException extends PlatformTaskDefinitionIncompatibilityException_base {
 }
-declare const PlatformUnknownException_base: S.ErrorClass<PlatformUnknownException, S.TaggedStruct<"PlatformUnknownException", {
+declare const PlatformUnknownException_base: S.Class<PlatformUnknownException, S.TaggedStruct<"PlatformUnknownException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PlatformUnknownException extends PlatformUnknownException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly resourceIds: S.optional<S.$Array<S.String>>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ServiceDeploymentNotFoundException_base: S.ErrorClass<ServiceDeploymentNotFoundException, S.TaggedStruct<"ServiceDeploymentNotFoundException", {
+declare const ServiceDeploymentNotFoundException_base: S.Class<ServiceDeploymentNotFoundException, S.TaggedStruct<"ServiceDeploymentNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceDeploymentNotFoundException extends ServiceDeploymentNotFoundException_base {
 }
-declare const BlockedException_base: S.ErrorClass<BlockedException, S.TaggedStruct<"BlockedException", {
+declare const BlockedException_base: S.Class<BlockedException, S.TaggedStruct<"BlockedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BlockedException extends BlockedException_base {

package/lib/services/efs.d.ts

@@ -485,7 +485,7 @@ export interface UpdateFileSystemProtectionRequest {
     ReplicationOverwriteProtection?: ReplicationOverwriteProtection;
 }
 export declare const UpdateFileSystemProtectionRequest: S.Schema<UpdateFileSystemProtectionRequest>;
-declare const AccessPointAlreadyExists_base: S.ErrorClass<AccessPointAlreadyExists, S.TaggedStruct<"AccessPointAlreadyExists", {
+declare const AccessPointAlreadyExists_base: S.Class<AccessPointAlreadyExists, S.TaggedStruct<"AccessPointAlreadyExists", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
     readonly AccessPointId: S.String;
@@ -500,7 +500,7 @@ declare const AccessPointAlreadyExists_base: S.ErrorClass<AccessPointAlreadyExis
 });
 export declare class AccessPointAlreadyExists extends AccessPointAlreadyExists_base {
 }
-declare const AccessPointLimitExceeded_base: S.ErrorClass<AccessPointLimitExceeded, S.TaggedStruct<"AccessPointLimitExceeded", {
+declare const AccessPointLimitExceeded_base: S.Class<AccessPointLimitExceeded, S.TaggedStruct<"AccessPointLimitExceeded", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -514,7 +514,7 @@ declare const AccessPointLimitExceeded_base: S.ErrorClass<AccessPointLimitExceed
 });
 export declare class AccessPointLimitExceeded extends AccessPointLimitExceeded_base {
 }
-declare const BadRequest_base: S.ErrorClass<BadRequest, S.TaggedStruct<"BadRequest", {
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -524,7 +524,7 @@ declare const BadRequest_base: S.ErrorClass<BadRequest, S.TaggedStruct<"BadReque
 });
 export declare class BadRequest extends BadRequest_base {
 }
-declare const FileSystemNotFound_base: S.ErrorClass<FileSystemNotFound, S.TaggedStruct<"FileSystemNotFound", {
+declare const FileSystemNotFound_base: S.Class<FileSystemNotFound, S.TaggedStruct<"FileSystemNotFound", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -534,7 +534,7 @@ declare const FileSystemNotFound_base: S.ErrorClass<FileSystemNotFound, S.Tagged
 });
 export declare class FileSystemNotFound extends FileSystemNotFound_base {
 }
-declare const IncorrectFileSystemLifeCycleState_base: S.ErrorClass<IncorrectFileSystemLifeCycleState, S.TaggedStruct<"IncorrectFileSystemLifeCycleState", {
+declare const IncorrectFileSystemLifeCycleState_base: S.Class<IncorrectFileSystemLifeCycleState, S.TaggedStruct<"IncorrectFileSystemLifeCycleState", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -544,7 +544,7 @@ declare const IncorrectFileSystemLifeCycleState_base: S.ErrorClass<IncorrectFile
 });
 export declare class IncorrectFileSystemLifeCycleState extends IncorrectFileSystemLifeCycleState_base {
 }
-declare const InternalServerError_base: S.ErrorClass<InternalServerError, S.TaggedStruct<"InternalServerError", {
+declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -554,7 +554,7 @@ declare const InternalServerError_base: S.ErrorClass<InternalServerError, S.Tagg
 });
 export declare class InternalServerError extends InternalServerError_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -564,7 +564,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const FileSystemAlreadyExists_base: S.ErrorClass<FileSystemAlreadyExists, S.TaggedStruct<"FileSystemAlreadyExists", {
+declare const FileSystemAlreadyExists_base: S.Class<FileSystemAlreadyExists, S.TaggedStruct<"FileSystemAlreadyExists", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
     readonly FileSystemId: S.String;
@@ -579,7 +579,7 @@ declare const FileSystemAlreadyExists_base: S.ErrorClass<FileSystemAlreadyExists
 });
 export declare class FileSystemAlreadyExists extends FileSystemAlreadyExists_base {
 }
-declare const FileSystemLimitExceeded_base: S.ErrorClass<FileSystemLimitExceeded, S.TaggedStruct<"FileSystemLimitExceeded", {
+declare const FileSystemLimitExceeded_base: S.Class<FileSystemLimitExceeded, S.TaggedStruct<"FileSystemLimitExceeded", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -593,7 +593,7 @@ declare const FileSystemLimitExceeded_base: S.ErrorClass<FileSystemLimitExceeded
 });
 export declare class FileSystemLimitExceeded extends FileSystemLimitExceeded_base {
 }
-declare const InsufficientThroughputCapacity_base: S.ErrorClass<InsufficientThroughputCapacity, S.TaggedStruct<"InsufficientThroughputCapacity", {
+declare const InsufficientThroughputCapacity_base: S.Class<InsufficientThroughputCapacity, S.TaggedStruct<"InsufficientThroughputCapacity", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -603,7 +603,7 @@ declare const InsufficientThroughputCapacity_base: S.ErrorClass<InsufficientThro
 });
 export declare class InsufficientThroughputCapacity extends InsufficientThroughputCapacity_base {
 }
-declare const ThroughputLimitExceeded_base: S.ErrorClass<ThroughputLimitExceeded, S.TaggedStruct<"ThroughputLimitExceeded", {
+declare const ThroughputLimitExceeded_base: S.Class<ThroughputLimitExceeded, S.TaggedStruct<"ThroughputLimitExceeded", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -617,7 +617,7 @@ declare const ThroughputLimitExceeded_base: S.ErrorClass<ThroughputLimitExceeded
 });
 export declare class ThroughputLimitExceeded extends ThroughputLimitExceeded_base {
 }
-declare const UnsupportedAvailabilityZone_base: S.ErrorClass<UnsupportedAvailabilityZone, S.TaggedStruct<"UnsupportedAvailabilityZone", {
+declare const UnsupportedAvailabilityZone_base: S.Class<UnsupportedAvailabilityZone, S.TaggedStruct<"UnsupportedAvailabilityZone", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -627,7 +627,7 @@ declare const UnsupportedAvailabilityZone_base: S.ErrorClass<UnsupportedAvailabi
 });
 export declare class UnsupportedAvailabilityZone extends UnsupportedAvailabilityZone_base {
 }
-declare const AvailabilityZonesMismatch_base: S.ErrorClass<AvailabilityZonesMismatch, S.TaggedStruct<"AvailabilityZonesMismatch", {
+declare const AvailabilityZonesMismatch_base: S.Class<AvailabilityZonesMismatch, S.TaggedStruct<"AvailabilityZonesMismatch", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -637,7 +637,7 @@ declare const AvailabilityZonesMismatch_base: S.ErrorClass<AvailabilityZonesMism
 });
 export declare class AvailabilityZonesMismatch extends AvailabilityZonesMismatch_base {
 }
-declare const IpAddressInUse_base: S.ErrorClass<IpAddressInUse, S.TaggedStruct<"IpAddressInUse", {
+declare const IpAddressInUse_base: S.Class<IpAddressInUse, S.TaggedStruct<"IpAddressInUse", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -651,7 +651,7 @@ declare const IpAddressInUse_base: S.ErrorClass<IpAddressInUse, S.TaggedStruct<"
 });
 export declare class IpAddressInUse extends IpAddressInUse_base {
 }
-declare const MountTargetConflict_base: S.ErrorClass<MountTargetConflict, S.TaggedStruct<"MountTargetConflict", {
+declare const MountTargetConflict_base: S.Class<MountTargetConflict, S.TaggedStruct<"MountTargetConflict", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -661,7 +661,7 @@ declare const MountTargetConflict_base: S.ErrorClass<MountTargetConflict, S.Tagg
 });
 export declare class MountTargetConflict extends MountTargetConflict_base {
 }
-declare const NetworkInterfaceLimitExceeded_base: S.ErrorClass<NetworkInterfaceLimitExceeded, S.TaggedStruct<"NetworkInterfaceLimitExceeded", {
+declare const NetworkInterfaceLimitExceeded_base: S.Class<NetworkInterfaceLimitExceeded, S.TaggedStruct<"NetworkInterfaceLimitExceeded", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -675,7 +675,7 @@ declare const NetworkInterfaceLimitExceeded_base: S.ErrorClass<NetworkInterfaceL
 });
 export declare class NetworkInterfaceLimitExceeded extends NetworkInterfaceLimitExceeded_base {
 }
-declare const NoFreeAddressesInSubnet_base: S.ErrorClass<NoFreeAddressesInSubnet, S.TaggedStruct<"NoFreeAddressesInSubnet", {
+declare const NoFreeAddressesInSubnet_base: S.Class<NoFreeAddressesInSubnet, S.TaggedStruct<"NoFreeAddressesInSubnet", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -685,7 +685,7 @@ declare const NoFreeAddressesInSubnet_base: S.ErrorClass<NoFreeAddressesInSubnet
 });
 export declare class NoFreeAddressesInSubnet extends NoFreeAddressesInSubnet_base {
 }
-declare const SecurityGroupLimitExceeded_base: S.ErrorClass<SecurityGroupLimitExceeded, S.TaggedStruct<"SecurityGroupLimitExceeded", {
+declare const SecurityGroupLimitExceeded_base: S.Class<SecurityGroupLimitExceeded, S.TaggedStruct<"SecurityGroupLimitExceeded", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -699,7 +699,7 @@ declare const SecurityGroupLimitExceeded_base: S.ErrorClass<SecurityGroupLimitEx
 });
 export declare class SecurityGroupLimitExceeded extends SecurityGroupLimitExceeded_base {
 }
-declare const SecurityGroupNotFound_base: S.ErrorClass<SecurityGroupNotFound, S.TaggedStruct<"SecurityGroupNotFound", {
+declare const SecurityGroupNotFound_base: S.Class<SecurityGroupNotFound, S.TaggedStruct<"SecurityGroupNotFound", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -709,7 +709,7 @@ declare const SecurityGroupNotFound_base: S.ErrorClass<SecurityGroupNotFound, S.
 });
 export declare class SecurityGroupNotFound extends SecurityGroupNotFound_base {
 }
-declare const SubnetNotFound_base: S.ErrorClass<SubnetNotFound, S.TaggedStruct<"SubnetNotFound", {
+declare const SubnetNotFound_base: S.Class<SubnetNotFound, S.TaggedStruct<"SubnetNotFound", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -719,7 +719,7 @@ declare const SubnetNotFound_base: S.ErrorClass<SubnetNotFound, S.TaggedStruct<"
 });
 export declare class SubnetNotFound extends SubnetNotFound_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -729,7 +729,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ReplicationNotFound_base: S.ErrorClass<ReplicationNotFound, S.TaggedStruct<"ReplicationNotFound", {
+declare const ReplicationNotFound_base: S.Class<ReplicationNotFound, S.TaggedStruct<"ReplicationNotFound", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -739,7 +739,7 @@ declare const ReplicationNotFound_base: S.ErrorClass<ReplicationNotFound, S.Tagg
 });
 export declare class ReplicationNotFound extends ReplicationNotFound_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -749,7 +749,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const AccessPointNotFound_base: S.ErrorClass<AccessPointNotFound, S.TaggedStruct<"AccessPointNotFound", {
+declare const AccessPointNotFound_base: S.Class<AccessPointNotFound, S.TaggedStruct<"AccessPointNotFound", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -759,7 +759,7 @@ declare const AccessPointNotFound_base: S.ErrorClass<AccessPointNotFound, S.Tagg
 });
 export declare class AccessPointNotFound extends AccessPointNotFound_base {
 }
-declare const FileSystemInUse_base: S.ErrorClass<FileSystemInUse, S.TaggedStruct<"FileSystemInUse", {
+declare const FileSystemInUse_base: S.Class<FileSystemInUse, S.TaggedStruct<"FileSystemInUse", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -773,7 +773,7 @@ declare const FileSystemInUse_base: S.ErrorClass<FileSystemInUse, S.TaggedStruct
 });
 export declare class FileSystemInUse extends FileSystemInUse_base {
 }
-declare const DependencyTimeout_base: S.ErrorClass<DependencyTimeout, S.TaggedStruct<"DependencyTimeout", {
+declare const DependencyTimeout_base: S.Class<DependencyTimeout, S.TaggedStruct<"DependencyTimeout", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -783,7 +783,7 @@ declare const DependencyTimeout_base: S.ErrorClass<DependencyTimeout, S.TaggedSt
 });
 export declare class DependencyTimeout extends DependencyTimeout_base {
 }
-declare const MountTargetNotFound_base: S.ErrorClass<MountTargetNotFound, S.TaggedStruct<"MountTargetNotFound", {
+declare const MountTargetNotFound_base: S.Class<MountTargetNotFound, S.TaggedStruct<"MountTargetNotFound", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -793,7 +793,7 @@ declare const MountTargetNotFound_base: S.ErrorClass<MountTargetNotFound, S.Tagg
 });
 export declare class MountTargetNotFound extends MountTargetNotFound_base {
 }
-declare const PolicyNotFound_base: S.ErrorClass<PolicyNotFound, S.TaggedStruct<"PolicyNotFound", {
+declare const PolicyNotFound_base: S.Class<PolicyNotFound, S.TaggedStruct<"PolicyNotFound", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -803,7 +803,7 @@ declare const PolicyNotFound_base: S.ErrorClass<PolicyNotFound, S.TaggedStruct<"
 });
 export declare class PolicyNotFound extends PolicyNotFound_base {
 }
-declare const IncorrectMountTargetState_base: S.ErrorClass<IncorrectMountTargetState, S.TaggedStruct<"IncorrectMountTargetState", {
+declare const IncorrectMountTargetState_base: S.Class<IncorrectMountTargetState, S.TaggedStruct<"IncorrectMountTargetState", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -813,7 +813,7 @@ declare const IncorrectMountTargetState_base: S.ErrorClass<IncorrectMountTargetS
 });
 export declare class IncorrectMountTargetState extends IncorrectMountTargetState_base {
 }
-declare const InvalidPolicyException_base: S.ErrorClass<InvalidPolicyException, S.TaggedStruct<"InvalidPolicyException", {
+declare const InvalidPolicyException_base: S.Class<InvalidPolicyException, S.TaggedStruct<"InvalidPolicyException", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -823,7 +823,7 @@ declare const InvalidPolicyException_base: S.ErrorClass<InvalidPolicyException,
 });
 export declare class InvalidPolicyException extends InvalidPolicyException_base {
 }
-declare const TooManyRequests_base: S.ErrorClass<TooManyRequests, S.TaggedStruct<"TooManyRequests", {
+declare const TooManyRequests_base: S.Class<TooManyRequests, S.TaggedStruct<"TooManyRequests", {
     readonly ErrorCode: S.String;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -833,7 +833,7 @@ declare const TooManyRequests_base: S.ErrorClass<TooManyRequests, S.TaggedStruct
 });
 export declare class TooManyRequests extends TooManyRequests_base {
 }
-declare const ReplicationAlreadyExists_base: S.ErrorClass<ReplicationAlreadyExists, S.TaggedStruct<"ReplicationAlreadyExists", {
+declare const ReplicationAlreadyExists_base: S.Class<ReplicationAlreadyExists, S.TaggedStruct<"ReplicationAlreadyExists", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/eks-auth.d.ts

@@ -42,7 +42,7 @@ export interface AssumeRoleForPodIdentityResponse {
     credentials: Credentials;
 }
 export declare const AssumeRoleForPodIdentityResponse: S.Schema<AssumeRoleForPodIdentityResponse>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -55,7 +55,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ExpiredTokenException_base: S.ErrorClass<ExpiredTokenException, S.TaggedStruct<"ExpiredTokenException", {
+declare const ExpiredTokenException_base: S.Class<ExpiredTokenException, S.TaggedStruct<"ExpiredTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -64,7 +64,7 @@ declare const ExpiredTokenException_base: S.ErrorClass<ExpiredTokenException, S.
 });
 export declare class ExpiredTokenException extends ExpiredTokenException_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": {
@@ -73,7 +73,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
+declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -82,7 +82,7 @@ declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterExcep
 });
 export declare class InvalidParameterException extends InvalidParameterException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -91,7 +91,7 @@ declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException
 });
 export declare class InvalidRequestException extends InvalidRequestException_base {
 }
-declare const InvalidTokenException_base: S.ErrorClass<InvalidTokenException, S.TaggedStruct<"InvalidTokenException", {
+declare const InvalidTokenException_base: S.Class<InvalidTokenException, S.TaggedStruct<"InvalidTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -100,7 +100,7 @@ declare const InvalidTokenException_base: S.ErrorClass<InvalidTokenException, S.
 });
 export declare class InvalidTokenException extends InvalidTokenException_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": {
@@ -109,7 +109,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
+declare const ServiceUnavailableException_base: S.Class<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -118,7 +118,7 @@ declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableE
 });
 export declare class ServiceUnavailableException extends ServiceUnavailableException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {