@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/ec2.d.ts

@@ -19396,764 +19396,764 @@ export interface WithdrawByoipCidrResult {
     ByoipCidr?: ByoipCidr;
 }
 export declare const WithdrawByoipCidrResult: S.Schema<WithdrawByoipCidrResult>;
-declare const RequestLimitExceeded_base: S.ErrorClass<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const RequestLimitExceeded_base: S.Class<RequestLimitExceeded, S.TaggedStruct<"RequestLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class RequestLimitExceeded extends RequestLimitExceeded_base {
 }
-declare const InvalidAddressMalformed_base: S.ErrorClass<InvalidAddressMalformed, S.TaggedStruct<"InvalidAddress.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAddressMalformed_base: S.Class<InvalidAddressMalformed, S.TaggedStruct<"InvalidAddress.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAddressMalformed extends InvalidAddressMalformed_base {
 }
-declare const InvalidAddressNotFound_base: S.ErrorClass<InvalidAddressNotFound, S.TaggedStruct<"InvalidAddress.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAddressNotFound_base: S.Class<InvalidAddressNotFound, S.TaggedStruct<"InvalidAddress.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAddressNotFound extends InvalidAddressNotFound_base {
 }
-declare const InvalidCapacityReservationIdMalformed_base: S.ErrorClass<InvalidCapacityReservationIdMalformed, S.TaggedStruct<"InvalidCapacityReservationId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityReservationIdMalformed_base: S.Class<InvalidCapacityReservationIdMalformed, S.TaggedStruct<"InvalidCapacityReservationId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityReservationIdMalformed extends InvalidCapacityReservationIdMalformed_base {
 }
-declare const InvalidReservedInstancesIDNotFound_base: S.ErrorClass<InvalidReservedInstancesIDNotFound, S.TaggedStruct<"InvalidReservedInstancesID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidReservedInstancesIDNotFound_base: S.Class<InvalidReservedInstancesIDNotFound, S.TaggedStruct<"InvalidReservedInstancesID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidReservedInstancesIDNotFound extends InvalidReservedInstancesIDNotFound_base {
 }
-declare const MissingParameter_base: S.ErrorClass<MissingParameter, S.TaggedStruct<"MissingParameter", {}>, import("effect/Cause").YieldableError>;
+declare const MissingParameter_base: S.Class<MissingParameter, S.TaggedStruct<"MissingParameter", {}>, import("effect/Cause").YieldableError>;
 export declare class MissingParameter extends MissingParameter_base {
 }
-declare const InvalidTransitGatewayAttachmentIDNotFound_base: S.ErrorClass<InvalidTransitGatewayAttachmentIDNotFound, S.TaggedStruct<"InvalidTransitGatewayAttachmentID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayAttachmentIDNotFound_base: S.Class<InvalidTransitGatewayAttachmentIDNotFound, S.TaggedStruct<"InvalidTransitGatewayAttachmentID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayAttachmentIDNotFound extends InvalidTransitGatewayAttachmentIDNotFound_base {
 }
-declare const InvalidParameter_base: S.ErrorClass<InvalidParameter, S.TaggedStruct<"InvalidParameter", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidParameter_base: S.Class<InvalidParameter, S.TaggedStruct<"InvalidParameter", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameter extends InvalidParameter_base {
 }
-declare const InvalidVpcEndpointServiceIdNotFound_base: S.ErrorClass<InvalidVpcEndpointServiceIdNotFound, S.TaggedStruct<"InvalidVpcEndpointServiceId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcEndpointServiceIdNotFound_base: S.Class<InvalidVpcEndpointServiceIdNotFound, S.TaggedStruct<"InvalidVpcEndpointServiceId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcEndpointServiceIdNotFound extends InvalidVpcEndpointServiceIdNotFound_base {
 }
-declare const InvalidVpcPeeringConnectionIDNotFound_base: S.ErrorClass<InvalidVpcPeeringConnectionIDNotFound, S.TaggedStruct<"InvalidVpcPeeringConnectionID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcPeeringConnectionIDNotFound_base: S.Class<InvalidVpcPeeringConnectionIDNotFound, S.TaggedStruct<"InvalidVpcPeeringConnectionID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcPeeringConnectionIDNotFound extends InvalidVpcPeeringConnectionIDNotFound_base {
 }
-declare const InvalidVpcPeeringConnectionIdNotFound_base: S.ErrorClass<InvalidVpcPeeringConnectionIdNotFound, S.TaggedStruct<"InvalidVpcPeeringConnectionId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcPeeringConnectionIdNotFound_base: S.Class<InvalidVpcPeeringConnectionIdNotFound, S.TaggedStruct<"InvalidVpcPeeringConnectionId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcPeeringConnectionIdNotFound extends InvalidVpcPeeringConnectionIdNotFound_base {
 }
-declare const AddressLimitExceeded_base: S.ErrorClass<AddressLimitExceeded, S.TaggedStruct<"AddressLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const AddressLimitExceeded_base: S.Class<AddressLimitExceeded, S.TaggedStruct<"AddressLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class AddressLimitExceeded extends AddressLimitExceeded_base {
 }
-declare const InvalidHostConfiguration_base: S.ErrorClass<InvalidHostConfiguration, S.TaggedStruct<"InvalidHostConfiguration", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidHostConfiguration_base: S.Class<InvalidHostConfiguration, S.TaggedStruct<"InvalidHostConfiguration", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidHostConfiguration extends InvalidHostConfiguration_base {
 }
-declare const InvalidRequest_base: S.ErrorClass<InvalidRequest, S.TaggedStruct<"InvalidRequest", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRequest_base: S.Class<InvalidRequest, S.TaggedStruct<"InvalidRequest", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequest extends InvalidRequest_base {
 }
-declare const InvalidIpamPoolIdNotFound_base: S.ErrorClass<InvalidIpamPoolIdNotFound, S.TaggedStruct<"InvalidIpamPoolId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPoolIdNotFound_base: S.Class<InvalidIpamPoolIdNotFound, S.TaggedStruct<"InvalidIpamPoolId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPoolIdNotFound extends InvalidIpamPoolIdNotFound_base {
 }
-declare const InvalidVpcIdMalformed_base: S.ErrorClass<InvalidVpcIdMalformed, S.TaggedStruct<"InvalidVpcId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcIdMalformed_base: S.Class<InvalidVpcIdMalformed, S.TaggedStruct<"InvalidVpcId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcIdMalformed extends InvalidVpcIdMalformed_base {
 }
-declare const InvalidNetworkInterfaceIDNotFound_base: S.ErrorClass<InvalidNetworkInterfaceIDNotFound, S.TaggedStruct<"InvalidNetworkInterfaceID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkInterfaceIDNotFound_base: S.Class<InvalidNetworkInterfaceIDNotFound, S.TaggedStruct<"InvalidNetworkInterfaceID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkInterfaceIDNotFound extends InvalidNetworkInterfaceIDNotFound_base {
 }
-declare const InvalidParameterCombination_base: S.ErrorClass<InvalidParameterCombination, S.TaggedStruct<"InvalidParameterCombination", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidParameterCombination_base: S.Class<InvalidParameterCombination, S.TaggedStruct<"InvalidParameterCombination", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterCombination extends InvalidParameterCombination_base {
 }
-declare const InvalidNetworkInterfaceIdMalformed_base: S.ErrorClass<InvalidNetworkInterfaceIdMalformed, S.TaggedStruct<"InvalidNetworkInterfaceId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkInterfaceIdMalformed_base: S.Class<InvalidNetworkInterfaceIdMalformed, S.TaggedStruct<"InvalidNetworkInterfaceId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkInterfaceIdMalformed extends InvalidNetworkInterfaceIdMalformed_base {
 }
-declare const NatGatewayNotFound_base: S.ErrorClass<NatGatewayNotFound, S.TaggedStruct<"NatGatewayNotFound", {}>, import("effect/Cause").YieldableError>;
+declare const NatGatewayNotFound_base: S.Class<NatGatewayNotFound, S.TaggedStruct<"NatGatewayNotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class NatGatewayNotFound extends NatGatewayNotFound_base {
 }
-declare const AuthFailure_base: S.ErrorClass<AuthFailure, S.TaggedStruct<"AuthFailure", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const AuthFailure_base: S.Class<AuthFailure, S.TaggedStruct<"AuthFailure", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class AuthFailure extends AuthFailure_base {
 }
-declare const InvalidAllocationIDNotFound_base: S.ErrorClass<InvalidAllocationIDNotFound, S.TaggedStruct<"InvalidAllocationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAllocationIDNotFound_base: S.Class<InvalidAllocationIDNotFound, S.TaggedStruct<"InvalidAllocationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAllocationIDNotFound extends InvalidAllocationIDNotFound_base {
 }
-declare const InvalidInstanceIDNotFound_base: S.ErrorClass<InvalidInstanceIDNotFound, S.TaggedStruct<"InvalidInstanceID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceIDNotFound_base: S.Class<InvalidInstanceIDNotFound, S.TaggedStruct<"InvalidInstanceID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceIDNotFound extends InvalidInstanceIDNotFound_base {
 }
-declare const InvalidSubnetIDMalformed_base: S.ErrorClass<InvalidSubnetIDMalformed, S.TaggedStruct<"InvalidSubnetID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetIDMalformed_base: S.Class<InvalidSubnetIDMalformed, S.TaggedStruct<"InvalidSubnetID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetIDMalformed extends InvalidSubnetIDMalformed_base {
 }
-declare const InvalidDhcpOptionsIdMalformed_base: S.ErrorClass<InvalidDhcpOptionsIdMalformed, S.TaggedStruct<"InvalidDhcpOptionsId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidDhcpOptionsIdMalformed_base: S.Class<InvalidDhcpOptionsIdMalformed, S.TaggedStruct<"InvalidDhcpOptionsId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidDhcpOptionsIdMalformed extends InvalidDhcpOptionsIdMalformed_base {
 }
-declare const InvalidVpcIDNotFound_base: S.ErrorClass<InvalidVpcIDNotFound, S.TaggedStruct<"InvalidVpcID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcIDNotFound_base: S.Class<InvalidVpcIDNotFound, S.TaggedStruct<"InvalidVpcID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcIDNotFound extends InvalidVpcIDNotFound_base {
 }
-declare const InvalidCertificateArnMalformed_base: S.ErrorClass<InvalidCertificateArnMalformed, S.TaggedStruct<"InvalidCertificateArn.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCertificateArnMalformed_base: S.Class<InvalidCertificateArnMalformed, S.TaggedStruct<"InvalidCertificateArn.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCertificateArnMalformed extends InvalidCertificateArnMalformed_base {
 }
-declare const InvalidRoleArnMalformed_base: S.ErrorClass<InvalidRoleArnMalformed, S.TaggedStruct<"InvalidRoleArn.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRoleArnMalformed_base: S.Class<InvalidRoleArnMalformed, S.TaggedStruct<"InvalidRoleArn.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoleArnMalformed extends InvalidRoleArnMalformed_base {
 }
-declare const InvalidCidrNotFound_base: S.ErrorClass<InvalidCidrNotFound, S.TaggedStruct<"InvalidCidr.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCidrNotFound_base: S.Class<InvalidCidrNotFound, S.TaggedStruct<"InvalidCidr.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCidrNotFound extends InvalidCidrNotFound_base {
 }
-declare const InvalidIpamResourceDiscoveryIdMalformed_base: S.ErrorClass<InvalidIpamResourceDiscoveryIdMalformed, S.TaggedStruct<"InvalidIpamResourceDiscoveryId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamResourceDiscoveryIdMalformed_base: S.Class<InvalidIpamResourceDiscoveryIdMalformed, S.TaggedStruct<"InvalidIpamResourceDiscoveryId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamResourceDiscoveryIdMalformed extends InvalidIpamResourceDiscoveryIdMalformed_base {
 }
-declare const InvalidIpamResourceDiscoveryIdNotFound_base: S.ErrorClass<InvalidIpamResourceDiscoveryIdNotFound, S.TaggedStruct<"InvalidIpamResourceDiscoveryId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamResourceDiscoveryIdNotFound_base: S.Class<InvalidIpamResourceDiscoveryIdNotFound, S.TaggedStruct<"InvalidIpamResourceDiscoveryId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamResourceDiscoveryIdNotFound extends InvalidIpamResourceDiscoveryIdNotFound_base {
 }
-declare const NatGatewayMalformed_base: S.ErrorClass<NatGatewayMalformed, S.TaggedStruct<"NatGatewayMalformed", {}>, import("effect/Cause").YieldableError>;
+declare const NatGatewayMalformed_base: S.Class<NatGatewayMalformed, S.TaggedStruct<"NatGatewayMalformed", {}>, import("effect/Cause").YieldableError>;
 export declare class NatGatewayMalformed extends NatGatewayMalformed_base {
 }
-declare const InvalidRouteServerIdNotFound_base: S.ErrorClass<InvalidRouteServerIdNotFound, S.TaggedStruct<"InvalidRouteServerId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteServerIdNotFound_base: S.Class<InvalidRouteServerIdNotFound, S.TaggedStruct<"InvalidRouteServerId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteServerIdNotFound extends InvalidRouteServerIdNotFound_base {
 }
-declare const DryRunOperation_base: S.ErrorClass<DryRunOperation, S.TaggedStruct<"DryRunOperation", {}>, import("effect/Cause").YieldableError>;
+declare const DryRunOperation_base: S.Class<DryRunOperation, S.TaggedStruct<"DryRunOperation", {}>, import("effect/Cause").YieldableError>;
 export declare class DryRunOperation extends DryRunOperation_base {
 }
-declare const InvalidParameterValue_base: S.ErrorClass<InvalidParameterValue, S.TaggedStruct<"InvalidParameterValue", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidParameterValue_base: S.Class<InvalidParameterValue, S.TaggedStruct<"InvalidParameterValue", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterValue extends InvalidParameterValue_base {
 }
-declare const InvalidPublicIpv4PoolIDMalformed_base: S.ErrorClass<InvalidPublicIpv4PoolIDMalformed, S.TaggedStruct<"InvalidPublicIpv4PoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPublicIpv4PoolIDMalformed_base: S.Class<InvalidPublicIpv4PoolIDMalformed, S.TaggedStruct<"InvalidPublicIpv4PoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPublicIpv4PoolIDMalformed extends InvalidPublicIpv4PoolIDMalformed_base {
 }
-declare const InvalidPublicIpv4PoolIDNotFound_base: S.ErrorClass<InvalidPublicIpv4PoolIDNotFound, S.TaggedStruct<"InvalidPublicIpv4PoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPublicIpv4PoolIDNotFound_base: S.Class<InvalidPublicIpv4PoolIDNotFound, S.TaggedStruct<"InvalidPublicIpv4PoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPublicIpv4PoolIDNotFound extends InvalidPublicIpv4PoolIDNotFound_base {
 }
-declare const InvalidRouteTableIDNotFound_base: S.ErrorClass<InvalidRouteTableIDNotFound, S.TaggedStruct<"InvalidRouteTableID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteTableIDNotFound_base: S.Class<InvalidRouteTableIDNotFound, S.TaggedStruct<"InvalidRouteTableID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteTableIDNotFound extends InvalidRouteTableIDNotFound_base {
 }
-declare const InvalidSubnetIDNotFound_base: S.ErrorClass<InvalidSubnetIDNotFound, S.TaggedStruct<"InvalidSubnetID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetIDNotFound_base: S.Class<InvalidSubnetIDNotFound, S.TaggedStruct<"InvalidSubnetID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetIDNotFound extends InvalidSubnetIDNotFound_base {
 }
-declare const InvalidGroupIdMalformed_base: S.ErrorClass<InvalidGroupIdMalformed, S.TaggedStruct<"InvalidGroupId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidGroupIdMalformed_base: S.Class<InvalidGroupIdMalformed, S.TaggedStruct<"InvalidGroupId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidGroupIdMalformed extends InvalidGroupIdMalformed_base {
 }
-declare const InvalidTransitGatewayMulticastDomainIdNotFound_base: S.ErrorClass<InvalidTransitGatewayMulticastDomainIdNotFound, S.TaggedStruct<"InvalidTransitGatewayMulticastDomainId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayMulticastDomainIdNotFound_base: S.Class<InvalidTransitGatewayMulticastDomainIdNotFound, S.TaggedStruct<"InvalidTransitGatewayMulticastDomainId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayMulticastDomainIdNotFound extends InvalidTransitGatewayMulticastDomainIdNotFound_base {
 }
-declare const InvalidTransitGatewayPolicyTableIdMalformed_base: S.ErrorClass<InvalidTransitGatewayPolicyTableIdMalformed, S.TaggedStruct<"InvalidTransitGatewayPolicyTableId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayPolicyTableIdMalformed_base: S.Class<InvalidTransitGatewayPolicyTableIdMalformed, S.TaggedStruct<"InvalidTransitGatewayPolicyTableId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayPolicyTableIdMalformed extends InvalidTransitGatewayPolicyTableIdMalformed_base {
 }
-declare const InvalidTransitGatewayPolicyTableIdNotFound_base: S.ErrorClass<InvalidTransitGatewayPolicyTableIdNotFound, S.TaggedStruct<"InvalidTransitGatewayPolicyTableId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayPolicyTableIdNotFound_base: S.Class<InvalidTransitGatewayPolicyTableIdNotFound, S.TaggedStruct<"InvalidTransitGatewayPolicyTableId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayPolicyTableIdNotFound extends InvalidTransitGatewayPolicyTableIdNotFound_base {
 }
-declare const OperationNotPermitted_base: S.ErrorClass<OperationNotPermitted, S.TaggedStruct<"OperationNotPermitted", {}>, import("effect/Cause").YieldableError>;
+declare const OperationNotPermitted_base: S.Class<OperationNotPermitted, S.TaggedStruct<"OperationNotPermitted", {}>, import("effect/Cause").YieldableError>;
 export declare class OperationNotPermitted extends OperationNotPermitted_base {
 }
-declare const CidrConflict_base: S.ErrorClass<CidrConflict, S.TaggedStruct<"CidrConflict", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const CidrConflict_base: S.Class<CidrConflict, S.TaggedStruct<"CidrConflict", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ConflictError: true;
     };
 });
 export declare class CidrConflict extends CidrConflict_base {
 }
-declare const InvalidInstanceIDMalformed_base: S.ErrorClass<InvalidInstanceIDMalformed, S.TaggedStruct<"InvalidInstanceID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceIDMalformed_base: S.Class<InvalidInstanceIDMalformed, S.TaggedStruct<"InvalidInstanceID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceIDMalformed extends InvalidInstanceIDMalformed_base {
 }
-declare const InvalidInternetGatewayIDNotFound_base: S.ErrorClass<InvalidInternetGatewayIDNotFound, S.TaggedStruct<"InvalidInternetGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInternetGatewayIDNotFound_base: S.Class<InvalidInternetGatewayIDNotFound, S.TaggedStruct<"InvalidInternetGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInternetGatewayIDNotFound extends InvalidInternetGatewayIDNotFound_base {
 }
-declare const InvalidInternetGatewayIdMalformed_base: S.ErrorClass<InvalidInternetGatewayIdMalformed, S.TaggedStruct<"InvalidInternetGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInternetGatewayIdMalformed_base: S.Class<InvalidInternetGatewayIdMalformed, S.TaggedStruct<"InvalidInternetGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInternetGatewayIdMalformed extends InvalidInternetGatewayIdMalformed_base {
 }
-declare const InvalidVerifiedAccessInstanceIdNotFound_base: S.ErrorClass<InvalidVerifiedAccessInstanceIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessInstanceId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVerifiedAccessInstanceIdNotFound_base: S.Class<InvalidVerifiedAccessInstanceIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessInstanceId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVerifiedAccessInstanceIdNotFound extends InvalidVerifiedAccessInstanceIdNotFound_base {
 }
-declare const InvalidVolumeNotFound_base: S.ErrorClass<InvalidVolumeNotFound, S.TaggedStruct<"InvalidVolume.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVolumeNotFound_base: S.Class<InvalidVolumeNotFound, S.TaggedStruct<"InvalidVolume.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVolumeNotFound extends InvalidVolumeNotFound_base {
 }
-declare const InvalidVpnGatewayIDNotFound_base: S.ErrorClass<InvalidVpnGatewayIDNotFound, S.TaggedStruct<"InvalidVpnGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnGatewayIDNotFound_base: S.Class<InvalidVpnGatewayIDNotFound, S.TaggedStruct<"InvalidVpnGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnGatewayIDNotFound extends InvalidVpnGatewayIDNotFound_base {
 }
-declare const InvalidGroupNotFound_base: S.ErrorClass<InvalidGroupNotFound, S.TaggedStruct<"InvalidGroup.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidGroupNotFound_base: S.Class<InvalidGroupNotFound, S.TaggedStruct<"InvalidGroup.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidGroupNotFound extends InvalidGroupNotFound_base {
 }
-declare const InvalidBundleIDNotFound_base: S.ErrorClass<InvalidBundleIDNotFound, S.TaggedStruct<"InvalidBundleID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidBundleIDNotFound_base: S.Class<InvalidBundleIDNotFound, S.TaggedStruct<"InvalidBundleID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidBundleIDNotFound extends InvalidBundleIDNotFound_base {
 }
-declare const InvalidCapacityReservationFleetIdMalformed_base: S.ErrorClass<InvalidCapacityReservationFleetIdMalformed, S.TaggedStruct<"InvalidCapacityReservationFleetId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityReservationFleetIdMalformed_base: S.Class<InvalidCapacityReservationFleetIdMalformed, S.TaggedStruct<"InvalidCapacityReservationFleetId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityReservationFleetIdMalformed extends InvalidCapacityReservationFleetIdMalformed_base {
 }
-declare const InvalidAction_base: S.ErrorClass<InvalidAction, S.TaggedStruct<"InvalidAction", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAction_base: S.Class<InvalidAction, S.TaggedStruct<"InvalidAction", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAction extends InvalidAction_base {
 }
-declare const InvalidDeclarativePoliciesReportIdMalformed_base: S.ErrorClass<InvalidDeclarativePoliciesReportIdMalformed, S.TaggedStruct<"InvalidDeclarativePoliciesReportId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidDeclarativePoliciesReportIdMalformed_base: S.Class<InvalidDeclarativePoliciesReportIdMalformed, S.TaggedStruct<"InvalidDeclarativePoliciesReportId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeclarativePoliciesReportIdMalformed extends InvalidDeclarativePoliciesReportIdMalformed_base {
 }
-declare const InvalidID_base: S.ErrorClass<InvalidID, S.TaggedStruct<"InvalidID", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidID_base: S.Class<InvalidID, S.TaggedStruct<"InvalidID", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidID extends InvalidID_base {
 }
-declare const InvalidAMIIDMalformed_base: S.ErrorClass<InvalidAMIIDMalformed, S.TaggedStruct<"InvalidAMIID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAMIIDMalformed_base: S.Class<InvalidAMIIDMalformed, S.TaggedStruct<"InvalidAMIID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAMIIDMalformed extends InvalidAMIIDMalformed_base {
 }
-declare const InvalidConversionTaskIdMalformed_base: S.ErrorClass<InvalidConversionTaskIdMalformed, S.TaggedStruct<"InvalidConversionTaskId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidConversionTaskIdMalformed_base: S.Class<InvalidConversionTaskIdMalformed, S.TaggedStruct<"InvalidConversionTaskId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidConversionTaskIdMalformed extends InvalidConversionTaskIdMalformed_base {
 }
-declare const InvalidInput_base: S.ErrorClass<InvalidInput, S.TaggedStruct<"InvalidInput", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInput_base: S.Class<InvalidInput, S.TaggedStruct<"InvalidInput", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInput extends InvalidInput_base {
 }
-declare const InvalidSpotInstanceRequestIDMalformed_base: S.ErrorClass<InvalidSpotInstanceRequestIDMalformed, S.TaggedStruct<"InvalidSpotInstanceRequestID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSpotInstanceRequestIDMalformed_base: S.Class<InvalidSpotInstanceRequestIDMalformed, S.TaggedStruct<"InvalidSpotInstanceRequestID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSpotInstanceRequestIDMalformed extends InvalidSpotInstanceRequestIDMalformed_base {
 }
-declare const InvalidFpgaImageIDMalformed_base: S.ErrorClass<InvalidFpgaImageIDMalformed, S.TaggedStruct<"InvalidFpgaImageID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidFpgaImageIDMalformed_base: S.Class<InvalidFpgaImageIDMalformed, S.TaggedStruct<"InvalidFpgaImageID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidFpgaImageIDMalformed extends InvalidFpgaImageIDMalformed_base {
 }
-declare const InvalidAMIIDNotFound_base: S.ErrorClass<InvalidAMIIDNotFound, S.TaggedStruct<"InvalidAMIID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAMIIDNotFound_base: S.Class<InvalidAMIIDNotFound, S.TaggedStruct<"InvalidAMIID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAMIIDNotFound extends InvalidAMIIDNotFound_base {
 }
-declare const InvalidRegion_base: S.ErrorClass<InvalidRegion, S.TaggedStruct<"InvalidRegion", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRegion_base: S.Class<InvalidRegion, S.TaggedStruct<"InvalidRegion", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRegion extends InvalidRegion_base {
 }
-declare const InvalidSnapshotNotFound_base: S.ErrorClass<InvalidSnapshotNotFound, S.TaggedStruct<"InvalidSnapshot.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSnapshotNotFound_base: S.Class<InvalidSnapshotNotFound, S.TaggedStruct<"InvalidSnapshot.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSnapshotNotFound extends InvalidSnapshotNotFound_base {
 }
-declare const InvalidVolumeIDMalformed_base: S.ErrorClass<InvalidVolumeIDMalformed, S.TaggedStruct<"InvalidVolumeID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVolumeIDMalformed_base: S.Class<InvalidVolumeIDMalformed, S.TaggedStruct<"InvalidVolumeID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVolumeIDMalformed extends InvalidVolumeIDMalformed_base {
 }
-declare const Unsupported_base: S.ErrorClass<Unsupported, S.TaggedStruct<"Unsupported", {}>, import("effect/Cause").YieldableError>;
+declare const Unsupported_base: S.Class<Unsupported, S.TaggedStruct<"Unsupported", {}>, import("effect/Cause").YieldableError>;
 export declare class Unsupported extends Unsupported_base {
 }
-declare const InvalidCapacityReservationIdNotFound_base: S.ErrorClass<InvalidCapacityReservationIdNotFound, S.TaggedStruct<"InvalidCapacityReservationId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityReservationIdNotFound_base: S.Class<InvalidCapacityReservationIdNotFound, S.TaggedStruct<"InvalidCapacityReservationId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityReservationIdNotFound extends InvalidCapacityReservationIdNotFound_base {
 }
-declare const ParseError_base: S.ErrorClass<ParseError, S.TaggedStruct<"ParseError", {}>, import("effect/Cause").YieldableError>;
+declare const ParseError_base: S.Class<ParseError, S.TaggedStruct<"ParseError", {}>, import("effect/Cause").YieldableError>;
 export declare class ParseError extends ParseError_base {
 }
-declare const InvalidClientVpnEndpointIdNotFound_base: S.ErrorClass<InvalidClientVpnEndpointIdNotFound, S.TaggedStruct<"InvalidClientVpnEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidClientVpnEndpointIdNotFound_base: S.Class<InvalidClientVpnEndpointIdNotFound, S.TaggedStruct<"InvalidClientVpnEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidClientVpnEndpointIdNotFound extends InvalidClientVpnEndpointIdNotFound_base {
 }
-declare const InvalidPoolIDMalformed_base: S.ErrorClass<InvalidPoolIDMalformed, S.TaggedStruct<"InvalidPoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPoolIDMalformed_base: S.Class<InvalidPoolIDMalformed, S.TaggedStruct<"InvalidPoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPoolIDMalformed extends InvalidPoolIDMalformed_base {
 }
-declare const InvalidPoolIDNotFound_base: S.ErrorClass<InvalidPoolIDNotFound, S.TaggedStruct<"InvalidPoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPoolIDNotFound_base: S.Class<InvalidPoolIDNotFound, S.TaggedStruct<"InvalidPoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPoolIDNotFound extends InvalidPoolIDNotFound_base {
 }
-declare const InvalidLocalGatewayRouteTableIDMalformed_base: S.ErrorClass<InvalidLocalGatewayRouteTableIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableIDMalformed_base: S.Class<InvalidLocalGatewayRouteTableIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableIDMalformed extends InvalidLocalGatewayRouteTableIDMalformed_base {
 }
-declare const InvalidLocalGatewayRouteTableIDNotFound_base: S.ErrorClass<InvalidLocalGatewayRouteTableIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableIDNotFound_base: S.Class<InvalidLocalGatewayRouteTableIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableIDNotFound extends InvalidLocalGatewayRouteTableIDNotFound_base {
 }
-declare const DefaultSubnetAlreadyExistsInAvailabilityZone_base: S.ErrorClass<DefaultSubnetAlreadyExistsInAvailabilityZone, S.TaggedStruct<"DefaultSubnetAlreadyExistsInAvailabilityZone", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const DefaultSubnetAlreadyExistsInAvailabilityZone_base: S.Class<DefaultSubnetAlreadyExistsInAvailabilityZone, S.TaggedStruct<"DefaultSubnetAlreadyExistsInAvailabilityZone", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
 });
 export declare class DefaultSubnetAlreadyExistsInAvailabilityZone extends DefaultSubnetAlreadyExistsInAvailabilityZone_base {
 }
-declare const DefaultVpcAlreadyExists_base: S.ErrorClass<DefaultVpcAlreadyExists, S.TaggedStruct<"DefaultVpcAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const DefaultVpcAlreadyExists_base: S.Class<DefaultVpcAlreadyExists, S.TaggedStruct<"DefaultVpcAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
 });
 export declare class DefaultVpcAlreadyExists extends DefaultVpcAlreadyExists_base {
 }
-declare const InternetGatewayLimitExceeded_base: S.ErrorClass<InternetGatewayLimitExceeded, S.TaggedStruct<"InternetGatewayLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InternetGatewayLimitExceeded_base: S.Class<InternetGatewayLimitExceeded, S.TaggedStruct<"InternetGatewayLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class InternetGatewayLimitExceeded extends InternetGatewayLimitExceeded_base {
 }
-declare const ResourceLimitExceeded_base: S.ErrorClass<ResourceLimitExceeded, S.TaggedStruct<"ResourceLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const ResourceLimitExceeded_base: S.Class<ResourceLimitExceeded, S.TaggedStruct<"ResourceLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class ResourceLimitExceeded extends ResourceLimitExceeded_base {
 }
-declare const InvalidIpamIdNotFound_base: S.ErrorClass<InvalidIpamIdNotFound, S.TaggedStruct<"InvalidIpamId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamIdNotFound_base: S.Class<InvalidIpamIdNotFound, S.TaggedStruct<"InvalidIpamId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamIdNotFound extends InvalidIpamIdNotFound_base {
 }
-declare const InvalidIpamScopeIdNotFound_base: S.ErrorClass<InvalidIpamScopeIdNotFound, S.TaggedStruct<"InvalidIpamScopeId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamScopeIdNotFound_base: S.Class<InvalidIpamScopeIdNotFound, S.TaggedStruct<"InvalidIpamScopeId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamScopeIdNotFound extends InvalidIpamScopeIdNotFound_base {
 }
-declare const InvalidIpamPrefixListResolverIdMalformed_base: S.ErrorClass<InvalidIpamPrefixListResolverIdMalformed, S.TaggedStruct<"InvalidIpamPrefixListResolverId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPrefixListResolverIdMalformed_base: S.Class<InvalidIpamPrefixListResolverIdMalformed, S.TaggedStruct<"InvalidIpamPrefixListResolverId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPrefixListResolverIdMalformed extends InvalidIpamPrefixListResolverIdMalformed_base {
 }
-declare const InvalidIpamPrefixListResolverIdNotFound_base: S.ErrorClass<InvalidIpamPrefixListResolverIdNotFound, S.TaggedStruct<"InvalidIpamPrefixListResolverId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPrefixListResolverIdNotFound_base: S.Class<InvalidIpamPrefixListResolverIdNotFound, S.TaggedStruct<"InvalidIpamPrefixListResolverId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPrefixListResolverIdNotFound extends InvalidIpamPrefixListResolverIdNotFound_base {
 }
-declare const InvalidKeyPairDuplicate_base: S.ErrorClass<InvalidKeyPairDuplicate, S.TaggedStruct<"InvalidKeyPair.Duplicate", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidKeyPairDuplicate_base: S.Class<InvalidKeyPairDuplicate, S.TaggedStruct<"InvalidKeyPair.Duplicate", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
 });
 export declare class InvalidKeyPairDuplicate extends InvalidKeyPairDuplicate_base {
 }
-declare const InvalidLocalGatewayIDMalformed_base: S.ErrorClass<InvalidLocalGatewayIDMalformed, S.TaggedStruct<"InvalidLocalGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayIDMalformed_base: S.Class<InvalidLocalGatewayIDMalformed, S.TaggedStruct<"InvalidLocalGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayIDMalformed extends InvalidLocalGatewayIDMalformed_base {
 }
-declare const InvalidLocalGatewayIDNotFound_base: S.ErrorClass<InvalidLocalGatewayIDNotFound, S.TaggedStruct<"InvalidLocalGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayIDNotFound_base: S.Class<InvalidLocalGatewayIDNotFound, S.TaggedStruct<"InvalidLocalGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayIDNotFound extends InvalidLocalGatewayIDNotFound_base {
 }
-declare const InvalidLocalGatewayVirtualInterfaceGroupIDMalformed_base: S.ErrorClass<InvalidLocalGatewayVirtualInterfaceGroupIDMalformed, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceGroupID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayVirtualInterfaceGroupIDMalformed_base: S.Class<InvalidLocalGatewayVirtualInterfaceGroupIDMalformed, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceGroupID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayVirtualInterfaceGroupIDMalformed extends InvalidLocalGatewayVirtualInterfaceGroupIDMalformed_base {
 }
-declare const InvalidLocalGatewayVirtualInterfaceGroupIDNotFound_base: S.ErrorClass<InvalidLocalGatewayVirtualInterfaceGroupIDNotFound, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceGroupID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayVirtualInterfaceGroupIDNotFound_base: S.Class<InvalidLocalGatewayVirtualInterfaceGroupIDNotFound, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceGroupID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayVirtualInterfaceGroupIDNotFound extends InvalidLocalGatewayVirtualInterfaceGroupIDNotFound_base {
 }
-declare const InvalidElasticIpIDNotFound_base: S.ErrorClass<InvalidElasticIpIDNotFound, S.TaggedStruct<"InvalidElasticIpID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidElasticIpIDNotFound_base: S.Class<InvalidElasticIpIDNotFound, S.TaggedStruct<"InvalidElasticIpID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidElasticIpIDNotFound extends InvalidElasticIpIDNotFound_base {
 }
-declare const InvalidSubnet_base: S.ErrorClass<InvalidSubnet, S.TaggedStruct<"InvalidSubnet", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnet_base: S.Class<InvalidSubnet, S.TaggedStruct<"InvalidSubnet", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnet extends InvalidSubnet_base {
 }
-declare const InvalidNetworkAclIDNotFound_base: S.ErrorClass<InvalidNetworkAclIDNotFound, S.TaggedStruct<"InvalidNetworkAclID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkAclIDNotFound_base: S.Class<InvalidNetworkAclIDNotFound, S.TaggedStruct<"InvalidNetworkAclID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkAclIDNotFound extends InvalidNetworkAclIDNotFound_base {
 }
-declare const InvalidGatewayIDNotFound_base: S.ErrorClass<InvalidGatewayIDNotFound, S.TaggedStruct<"InvalidGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidGatewayIDNotFound_base: S.Class<InvalidGatewayIDNotFound, S.TaggedStruct<"InvalidGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidGatewayIDNotFound extends InvalidGatewayIDNotFound_base {
 }
-declare const InvalidPrefixListIDNotFound_base: S.ErrorClass<InvalidPrefixListIDNotFound, S.TaggedStruct<"InvalidPrefixListID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPrefixListIDNotFound_base: S.Class<InvalidPrefixListIDNotFound, S.TaggedStruct<"InvalidPrefixListID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPrefixListIDNotFound extends InvalidPrefixListIDNotFound_base {
 }
-declare const InvalidRouteTableIdMalformed_base: S.ErrorClass<InvalidRouteTableIdMalformed, S.TaggedStruct<"InvalidRouteTableId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteTableIdMalformed_base: S.Class<InvalidRouteTableIdMalformed, S.TaggedStruct<"InvalidRouteTableId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteTableIdMalformed extends InvalidRouteTableIdMalformed_base {
 }
-declare const InvalidVpcEndpointIdNotFound_base: S.ErrorClass<InvalidVpcEndpointIdNotFound, S.TaggedStruct<"InvalidVpcEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcEndpointIdNotFound_base: S.Class<InvalidVpcEndpointIdNotFound, S.TaggedStruct<"InvalidVpcEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcEndpointIdNotFound extends InvalidVpcEndpointIdNotFound_base {
 }
-declare const InvalidRouteServerIdNotAssociated_base: S.ErrorClass<InvalidRouteServerIdNotAssociated, S.TaggedStruct<"InvalidRouteServerId.NotAssociated", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteServerIdNotAssociated_base: S.Class<InvalidRouteServerIdNotAssociated, S.TaggedStruct<"InvalidRouteServerId.NotAssociated", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteServerIdNotAssociated extends InvalidRouteServerIdNotAssociated_base {
 }
-declare const InvalidGroupDuplicate_base: S.ErrorClass<InvalidGroupDuplicate, S.TaggedStruct<"InvalidGroup.Duplicate", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidGroupDuplicate_base: S.Class<InvalidGroupDuplicate, S.TaggedStruct<"InvalidGroup.Duplicate", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
 });
 export declare class InvalidGroupDuplicate extends InvalidGroupDuplicate_base {
 }
-declare const VPCIdNotSpecified_base: S.ErrorClass<VPCIdNotSpecified, S.TaggedStruct<"VPCIdNotSpecified", {}>, import("effect/Cause").YieldableError>;
+declare const VPCIdNotSpecified_base: S.Class<VPCIdNotSpecified, S.TaggedStruct<"VPCIdNotSpecified", {}>, import("effect/Cause").YieldableError>;
 export declare class VPCIdNotSpecified extends VPCIdNotSpecified_base {
 }
-declare const InaccessibleStorageLocation_base: S.ErrorClass<InaccessibleStorageLocation, S.TaggedStruct<"InaccessibleStorageLocation", {}>, import("effect/Cause").YieldableError>;
+declare const InaccessibleStorageLocation_base: S.Class<InaccessibleStorageLocation, S.TaggedStruct<"InaccessibleStorageLocation", {}>, import("effect/Cause").YieldableError>;
 export declare class InaccessibleStorageLocation extends InaccessibleStorageLocation_base {
 }
-declare const TransitGatewayLimitExceeded_base: S.ErrorClass<TransitGatewayLimitExceeded, S.TaggedStruct<"TransitGatewayLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const TransitGatewayLimitExceeded_base: S.Class<TransitGatewayLimitExceeded, S.TaggedStruct<"TransitGatewayLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class TransitGatewayLimitExceeded extends TransitGatewayLimitExceeded_base {
 }
-declare const IncorrectState_base: S.ErrorClass<IncorrectState, S.TaggedStruct<"IncorrectState", {}>, import("effect/Cause").YieldableError>;
+declare const IncorrectState_base: S.Class<IncorrectState, S.TaggedStruct<"IncorrectState", {}>, import("effect/Cause").YieldableError>;
 export declare class IncorrectState extends IncorrectState_base {
 }
-declare const InvalidTransitGatewayIDNotFound_base: S.ErrorClass<InvalidTransitGatewayIDNotFound, S.TaggedStruct<"InvalidTransitGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayIDNotFound_base: S.Class<InvalidTransitGatewayIDNotFound, S.TaggedStruct<"InvalidTransitGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayIDNotFound extends InvalidTransitGatewayIDNotFound_base {
 }
-declare const InvalidTransitGatewayIDMalformed_base: S.ErrorClass<InvalidTransitGatewayIDMalformed, S.TaggedStruct<"InvalidTransitGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayIDMalformed_base: S.Class<InvalidTransitGatewayIDMalformed, S.TaggedStruct<"InvalidTransitGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayIDMalformed extends InvalidTransitGatewayIDMalformed_base {
 }
-declare const InvalidTransitGatewayAttachmentIDMalformed_base: S.ErrorClass<InvalidTransitGatewayAttachmentIDMalformed, S.TaggedStruct<"InvalidTransitGatewayAttachmentID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayAttachmentIDMalformed_base: S.Class<InvalidTransitGatewayAttachmentIDMalformed, S.TaggedStruct<"InvalidTransitGatewayAttachmentID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayAttachmentIDMalformed extends InvalidTransitGatewayAttachmentIDMalformed_base {
 }
-declare const VerifiedAccessInstanceLimitExceeded_base: S.ErrorClass<VerifiedAccessInstanceLimitExceeded, S.TaggedStruct<"VerifiedAccessInstanceLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const VerifiedAccessInstanceLimitExceeded_base: S.Class<VerifiedAccessInstanceLimitExceeded, S.TaggedStruct<"VerifiedAccessInstanceLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class VerifiedAccessInstanceLimitExceeded extends VerifiedAccessInstanceLimitExceeded_base {
 }
-declare const InvalidZoneNotFound_base: S.ErrorClass<InvalidZoneNotFound, S.TaggedStruct<"InvalidZone.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidZoneNotFound_base: S.Class<InvalidZoneNotFound, S.TaggedStruct<"InvalidZone.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidZoneNotFound extends InvalidZoneNotFound_base {
 }
-declare const VpcLimitExceeded_base: S.ErrorClass<VpcLimitExceeded, S.TaggedStruct<"VpcLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const VpcLimitExceeded_base: S.Class<VpcLimitExceeded, S.TaggedStruct<"VpcLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class VpcLimitExceeded extends VpcLimitExceeded_base {
 }
-declare const InvalidServiceName_base: S.ErrorClass<InvalidServiceName, S.TaggedStruct<"InvalidServiceName", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidServiceName_base: S.Class<InvalidServiceName, S.TaggedStruct<"InvalidServiceName", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidServiceName extends InvalidServiceName_base {
 }
-declare const InvalidVpcIdNotFound_base: S.ErrorClass<InvalidVpcIdNotFound, S.TaggedStruct<"InvalidVpcId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcIdNotFound_base: S.Class<InvalidVpcIdNotFound, S.TaggedStruct<"InvalidVpcId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcIdNotFound extends InvalidVpcIdNotFound_base {
 }
-declare const InvalidCustomerGatewayIDNotFound_base: S.ErrorClass<InvalidCustomerGatewayIDNotFound, S.TaggedStruct<"InvalidCustomerGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCustomerGatewayIDNotFound_base: S.Class<InvalidCustomerGatewayIDNotFound, S.TaggedStruct<"InvalidCustomerGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCustomerGatewayIDNotFound extends InvalidCustomerGatewayIDNotFound_base {
 }
-declare const InvalidCapacityManagerDataExportIdMalformed_base: S.ErrorClass<InvalidCapacityManagerDataExportIdMalformed, S.TaggedStruct<"InvalidCapacityManagerDataExportId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityManagerDataExportIdMalformed_base: S.Class<InvalidCapacityManagerDataExportIdMalformed, S.TaggedStruct<"InvalidCapacityManagerDataExportId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityManagerDataExportIdMalformed extends InvalidCapacityManagerDataExportIdMalformed_base {
 }
-declare const InvalidCapacityManagerDataExportIdNotFound_base: S.ErrorClass<InvalidCapacityManagerDataExportIdNotFound, S.TaggedStruct<"InvalidCapacityManagerDataExportId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityManagerDataExportIdNotFound_base: S.Class<InvalidCapacityManagerDataExportIdNotFound, S.TaggedStruct<"InvalidCapacityManagerDataExportId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityManagerDataExportIdNotFound extends InvalidCapacityManagerDataExportIdNotFound_base {
 }
-declare const InvalidCarrierGatewayIDMalformed_base: S.ErrorClass<InvalidCarrierGatewayIDMalformed, S.TaggedStruct<"InvalidCarrierGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCarrierGatewayIDMalformed_base: S.Class<InvalidCarrierGatewayIDMalformed, S.TaggedStruct<"InvalidCarrierGatewayID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCarrierGatewayIDMalformed extends InvalidCarrierGatewayIDMalformed_base {
 }
-declare const InvalidCarrierGatewayIDNotFound_base: S.ErrorClass<InvalidCarrierGatewayIDNotFound, S.TaggedStruct<"InvalidCarrierGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCarrierGatewayIDNotFound_base: S.Class<InvalidCarrierGatewayIDNotFound, S.TaggedStruct<"InvalidCarrierGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCarrierGatewayIDNotFound extends InvalidCarrierGatewayIDNotFound_base {
 }
-declare const InvalidCidrBlockMalformed_base: S.ErrorClass<InvalidCidrBlockMalformed, S.TaggedStruct<"InvalidCidrBlock.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCidrBlockMalformed_base: S.Class<InvalidCidrBlockMalformed, S.TaggedStruct<"InvalidCidrBlock.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCidrBlockMalformed extends InvalidCidrBlockMalformed_base {
 }
-declare const InvalidIpv4PoolCoipIdMalformed_base: S.ErrorClass<InvalidIpv4PoolCoipIdMalformed, S.TaggedStruct<"InvalidIpv4PoolCoipId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpv4PoolCoipIdMalformed_base: S.Class<InvalidIpv4PoolCoipIdMalformed, S.TaggedStruct<"InvalidIpv4PoolCoipId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpv4PoolCoipIdMalformed extends InvalidIpv4PoolCoipIdMalformed_base {
 }
-declare const InvalidCustomerGatewayIdMalformed_base: S.ErrorClass<InvalidCustomerGatewayIdMalformed, S.TaggedStruct<"InvalidCustomerGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCustomerGatewayIdMalformed_base: S.Class<InvalidCustomerGatewayIdMalformed, S.TaggedStruct<"InvalidCustomerGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCustomerGatewayIdMalformed extends InvalidCustomerGatewayIdMalformed_base {
 }
-declare const DependencyViolation_base: S.ErrorClass<DependencyViolation, S.TaggedStruct<"DependencyViolation", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const DependencyViolation_base: S.Class<DependencyViolation, S.TaggedStruct<"DependencyViolation", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         DependencyViolationError: true;
     };
 });
 export declare class DependencyViolation extends DependencyViolation_base {
 }
-declare const InvalidDhcpOptionIDNotFound_base: S.ErrorClass<InvalidDhcpOptionIDNotFound, S.TaggedStruct<"InvalidDhcpOptionID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidDhcpOptionIDNotFound_base: S.Class<InvalidDhcpOptionIDNotFound, S.TaggedStruct<"InvalidDhcpOptionID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidDhcpOptionIDNotFound extends InvalidDhcpOptionIDNotFound_base {
 }
-declare const InvalidDhcpOptionsIDNotFound_base: S.ErrorClass<InvalidDhcpOptionsIDNotFound, S.TaggedStruct<"InvalidDhcpOptionsID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidDhcpOptionsIDNotFound_base: S.Class<InvalidDhcpOptionsIDNotFound, S.TaggedStruct<"InvalidDhcpOptionsID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidDhcpOptionsIDNotFound extends InvalidDhcpOptionsIDNotFound_base {
 }
-declare const InvalidEgressOnlyInternetGatewayIdNotFound_base: S.ErrorClass<InvalidEgressOnlyInternetGatewayIdNotFound, S.TaggedStruct<"InvalidEgressOnlyInternetGatewayId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidEgressOnlyInternetGatewayIdNotFound_base: S.Class<InvalidEgressOnlyInternetGatewayIdNotFound, S.TaggedStruct<"InvalidEgressOnlyInternetGatewayId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidEgressOnlyInternetGatewayIdNotFound extends InvalidEgressOnlyInternetGatewayIdNotFound_base {
 }
-declare const MalformedGatewayIDNotFound_base: S.ErrorClass<MalformedGatewayIDNotFound, S.TaggedStruct<"MalformedGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const MalformedGatewayIDNotFound_base: S.Class<MalformedGatewayIDNotFound, S.TaggedStruct<"MalformedGatewayID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class MalformedGatewayIDNotFound extends MalformedGatewayIDNotFound_base {
 }
-declare const InvalidFleetIdMalformed_base: S.ErrorClass<InvalidFleetIdMalformed, S.TaggedStruct<"InvalidFleetId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidFleetIdMalformed_base: S.Class<InvalidFleetIdMalformed, S.TaggedStruct<"InvalidFleetId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidFleetIdMalformed extends InvalidFleetIdMalformed_base {
 }
-declare const InvalidFlowLogIdNotFound_base: S.ErrorClass<InvalidFlowLogIdNotFound, S.TaggedStruct<"InvalidFlowLogId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidFlowLogIdNotFound_base: S.Class<InvalidFlowLogIdNotFound, S.TaggedStruct<"InvalidFlowLogId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidFlowLogIdNotFound extends InvalidFlowLogIdNotFound_base {
 }
-declare const InvalidImageUsageReportIdMalformed_base: S.ErrorClass<InvalidImageUsageReportIdMalformed, S.TaggedStruct<"InvalidImageUsageReportId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidImageUsageReportIdMalformed_base: S.Class<InvalidImageUsageReportIdMalformed, S.TaggedStruct<"InvalidImageUsageReportId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidImageUsageReportIdMalformed extends InvalidImageUsageReportIdMalformed_base {
 }
-declare const InvalidInstanceConnectEndpointIdMalformed_base: S.ErrorClass<InvalidInstanceConnectEndpointIdMalformed, S.TaggedStruct<"InvalidInstanceConnectEndpointId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceConnectEndpointIdMalformed_base: S.Class<InvalidInstanceConnectEndpointIdMalformed, S.TaggedStruct<"InvalidInstanceConnectEndpointId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceConnectEndpointIdMalformed extends InvalidInstanceConnectEndpointIdMalformed_base {
 }
-declare const InvalidInstanceConnectEndpointIdNotFound_base: S.ErrorClass<InvalidInstanceConnectEndpointIdNotFound, S.TaggedStruct<"InvalidInstanceConnectEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceConnectEndpointIdNotFound_base: S.Class<InvalidInstanceConnectEndpointIdNotFound, S.TaggedStruct<"InvalidInstanceConnectEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceConnectEndpointIdNotFound extends InvalidInstanceConnectEndpointIdNotFound_base {
 }
-declare const InvalidState_base: S.ErrorClass<InvalidState, S.TaggedStruct<"InvalidState", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidState_base: S.Class<InvalidState, S.TaggedStruct<"InvalidState", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidState extends InvalidState_base {
 }
-declare const InvalidInstanceEventWindowIDNotFound_base: S.ErrorClass<InvalidInstanceEventWindowIDNotFound, S.TaggedStruct<"InvalidInstanceEventWindowIDNotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceEventWindowIDNotFound_base: S.Class<InvalidInstanceEventWindowIDNotFound, S.TaggedStruct<"InvalidInstanceEventWindowIDNotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceEventWindowIDNotFound extends InvalidInstanceEventWindowIDNotFound_base {
 }
-declare const InvalidIpamExternalResourceVerificationTokenIdMalformed_base: S.ErrorClass<InvalidIpamExternalResourceVerificationTokenIdMalformed, S.TaggedStruct<"InvalidIpamExternalResourceVerificationTokenId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamExternalResourceVerificationTokenIdMalformed_base: S.Class<InvalidIpamExternalResourceVerificationTokenIdMalformed, S.TaggedStruct<"InvalidIpamExternalResourceVerificationTokenId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamExternalResourceVerificationTokenIdMalformed extends InvalidIpamExternalResourceVerificationTokenIdMalformed_base {
 }
-declare const InvalidIpamExternalResourceVerificationTokenIdNotFound_base: S.ErrorClass<InvalidIpamExternalResourceVerificationTokenIdNotFound, S.TaggedStruct<"InvalidIpamExternalResourceVerificationTokenId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamExternalResourceVerificationTokenIdNotFound_base: S.Class<InvalidIpamExternalResourceVerificationTokenIdNotFound, S.TaggedStruct<"InvalidIpamExternalResourceVerificationTokenId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamExternalResourceVerificationTokenIdNotFound extends InvalidIpamExternalResourceVerificationTokenIdNotFound_base {
 }
-declare const InvalidIpamPolicyIdMalformed_base: S.ErrorClass<InvalidIpamPolicyIdMalformed, S.TaggedStruct<"InvalidIpamPolicyId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPolicyIdMalformed_base: S.Class<InvalidIpamPolicyIdMalformed, S.TaggedStruct<"InvalidIpamPolicyId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPolicyIdMalformed extends InvalidIpamPolicyIdMalformed_base {
 }
-declare const InvalidIpamPolicyIdNotFound_base: S.ErrorClass<InvalidIpamPolicyIdNotFound, S.TaggedStruct<"InvalidIpamPolicyId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPolicyIdNotFound_base: S.Class<InvalidIpamPolicyIdNotFound, S.TaggedStruct<"InvalidIpamPolicyId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPolicyIdNotFound extends InvalidIpamPolicyIdNotFound_base {
 }
-declare const InvalidIpamPrefixListResolverTargetIdMalformed_base: S.ErrorClass<InvalidIpamPrefixListResolverTargetIdMalformed, S.TaggedStruct<"InvalidIpamPrefixListResolverTargetId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamPrefixListResolverTargetIdMalformed_base: S.Class<InvalidIpamPrefixListResolverTargetIdMalformed, S.TaggedStruct<"InvalidIpamPrefixListResolverTargetId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamPrefixListResolverTargetIdMalformed extends InvalidIpamPrefixListResolverTargetIdMalformed_base {
 }
-declare const InvalidLaunchTemplateNameNotFoundException_base: S.ErrorClass<InvalidLaunchTemplateNameNotFoundException, S.TaggedStruct<"InvalidLaunchTemplateName.NotFoundException", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLaunchTemplateNameNotFoundException_base: S.Class<InvalidLaunchTemplateNameNotFoundException, S.TaggedStruct<"InvalidLaunchTemplateName.NotFoundException", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLaunchTemplateNameNotFoundException extends InvalidLaunchTemplateNameNotFoundException_base {
 }
-declare const InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed_base: S.ErrorClass<InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed_base: S.Class<InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed extends InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDMalformed_base {
 }
-declare const InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound_base: S.ErrorClass<InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound_base: S.Class<InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound extends InvalidLocalGatewayRouteTableVirtualInterfaceGroupAssociationIDNotFound_base {
 }
-declare const InvalidLocalGatewayRouteTableVpcAssociationIDMalformed_base: S.ErrorClass<InvalidLocalGatewayRouteTableVpcAssociationIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableVpcAssociationID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableVpcAssociationIDMalformed_base: S.Class<InvalidLocalGatewayRouteTableVpcAssociationIDMalformed, S.TaggedStruct<"InvalidLocalGatewayRouteTableVpcAssociationID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableVpcAssociationIDMalformed extends InvalidLocalGatewayRouteTableVpcAssociationIDMalformed_base {
 }
-declare const InvalidLocalGatewayRouteTableVpcAssociationIDNotFound_base: S.ErrorClass<InvalidLocalGatewayRouteTableVpcAssociationIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableVpcAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayRouteTableVpcAssociationIDNotFound_base: S.Class<InvalidLocalGatewayRouteTableVpcAssociationIDNotFound, S.TaggedStruct<"InvalidLocalGatewayRouteTableVpcAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayRouteTableVpcAssociationIDNotFound extends InvalidLocalGatewayRouteTableVpcAssociationIDNotFound_base {
 }
-declare const InvalidLocalGatewayVirtualInterfaceIDMalformed_base: S.ErrorClass<InvalidLocalGatewayVirtualInterfaceIDMalformed, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayVirtualInterfaceIDMalformed_base: S.Class<InvalidLocalGatewayVirtualInterfaceIDMalformed, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayVirtualInterfaceIDMalformed extends InvalidLocalGatewayVirtualInterfaceIDMalformed_base {
 }
-declare const InvalidLocalGatewayVirtualInterfaceIDNotFound_base: S.ErrorClass<InvalidLocalGatewayVirtualInterfaceIDNotFound, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLocalGatewayVirtualInterfaceIDNotFound_base: S.Class<InvalidLocalGatewayVirtualInterfaceIDNotFound, S.TaggedStruct<"InvalidLocalGatewayVirtualInterfaceID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLocalGatewayVirtualInterfaceIDNotFound extends InvalidLocalGatewayVirtualInterfaceIDNotFound_base {
 }
-declare const InvalidPrefixListIdMalformed_base: S.ErrorClass<InvalidPrefixListIdMalformed, S.TaggedStruct<"InvalidPrefixListId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPrefixListIdMalformed_base: S.Class<InvalidPrefixListIdMalformed, S.TaggedStruct<"InvalidPrefixListId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPrefixListIdMalformed extends InvalidPrefixListIdMalformed_base {
 }
-declare const InvalidNetworkAclIdMalformed_base: S.ErrorClass<InvalidNetworkAclIdMalformed, S.TaggedStruct<"InvalidNetworkAclId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkAclIdMalformed_base: S.Class<InvalidNetworkAclIdMalformed, S.TaggedStruct<"InvalidNetworkAclId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkAclIdMalformed extends InvalidNetworkAclIdMalformed_base {
 }
-declare const InvalidNetworkAclEntryNotFound_base: S.ErrorClass<InvalidNetworkAclEntryNotFound, S.TaggedStruct<"InvalidNetworkAclEntry.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkAclEntryNotFound_base: S.Class<InvalidNetworkAclEntryNotFound, S.TaggedStruct<"InvalidNetworkAclEntry.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkAclEntryNotFound extends InvalidNetworkAclEntryNotFound_base {
 }
-declare const InvalidNetworkInsightsAccessScopeIdNotFound_base: S.ErrorClass<InvalidNetworkInsightsAccessScopeIdNotFound, S.TaggedStruct<"InvalidNetworkInsightsAccessScopeId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkInsightsAccessScopeIdNotFound_base: S.Class<InvalidNetworkInsightsAccessScopeIdNotFound, S.TaggedStruct<"InvalidNetworkInsightsAccessScopeId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkInsightsAccessScopeIdNotFound extends InvalidNetworkInsightsAccessScopeIdNotFound_base {
 }
-declare const InvalidNetworkInterfaceInUse_base: S.ErrorClass<InvalidNetworkInterfaceInUse, S.TaggedStruct<"InvalidNetworkInterface.InUse", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidNetworkInterfaceInUse_base: S.Class<InvalidNetworkInterfaceInUse, S.TaggedStruct<"InvalidNetworkInterface.InUse", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         DependencyViolationError: true;
     };
 });
 export declare class InvalidNetworkInterfaceInUse extends InvalidNetworkInterfaceInUse_base {
 }
-declare const InvalidPermissionIDMalformed_base: S.ErrorClass<InvalidPermissionIDMalformed, S.TaggedStruct<"InvalidPermissionID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPermissionIDMalformed_base: S.Class<InvalidPermissionIDMalformed, S.TaggedStruct<"InvalidPermissionID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPermissionIDMalformed extends InvalidPermissionIDMalformed_base {
 }
-declare const InvalidPermissionIDNotFound_base: S.ErrorClass<InvalidPermissionIDNotFound, S.TaggedStruct<"InvalidPermissionID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPermissionIDNotFound_base: S.Class<InvalidPermissionIDNotFound, S.TaggedStruct<"InvalidPermissionID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPermissionIDNotFound extends InvalidPermissionIDNotFound_base {
 }
-declare const InvalidPlacementGroupUnknown_base: S.ErrorClass<InvalidPlacementGroupUnknown, S.TaggedStruct<"InvalidPlacementGroup.Unknown", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPlacementGroupUnknown_base: S.Class<InvalidPlacementGroupUnknown, S.TaggedStruct<"InvalidPlacementGroup.Unknown", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPlacementGroupUnknown extends InvalidPlacementGroupUnknown_base {
 }
-declare const InvalidPublicIpv4PoolNotFound_base: S.ErrorClass<InvalidPublicIpv4PoolNotFound, S.TaggedStruct<"InvalidPublicIpv4Pool.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPublicIpv4PoolNotFound_base: S.Class<InvalidPublicIpv4PoolNotFound, S.TaggedStruct<"InvalidPublicIpv4Pool.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPublicIpv4PoolNotFound extends InvalidPublicIpv4PoolNotFound_base {
 }
-declare const InvalidRouteNotFound_base: S.ErrorClass<InvalidRouteNotFound, S.TaggedStruct<"InvalidRoute.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteNotFound_base: S.Class<InvalidRouteNotFound, S.TaggedStruct<"InvalidRoute.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteNotFound extends InvalidRouteNotFound_base {
 }
-declare const InvalidRouteServerEndpointIdNotFound_base: S.ErrorClass<InvalidRouteServerEndpointIdNotFound, S.TaggedStruct<"InvalidRouteServerEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteServerEndpointIdNotFound_base: S.Class<InvalidRouteServerEndpointIdNotFound, S.TaggedStruct<"InvalidRouteServerEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteServerEndpointIdNotFound extends InvalidRouteServerEndpointIdNotFound_base {
 }
-declare const InvalidRouteServerPeerIdMalformed_base: S.ErrorClass<InvalidRouteServerPeerIdMalformed, S.TaggedStruct<"InvalidRouteServerPeerId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteServerPeerIdMalformed_base: S.Class<InvalidRouteServerPeerIdMalformed, S.TaggedStruct<"InvalidRouteServerPeerId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteServerPeerIdMalformed extends InvalidRouteServerPeerIdMalformed_base {
 }
-declare const InvalidRouteServerPeerIdNotFound_base: S.ErrorClass<InvalidRouteServerPeerIdNotFound, S.TaggedStruct<"InvalidRouteServerPeerId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteServerPeerIdNotFound_base: S.Class<InvalidRouteServerPeerIdNotFound, S.TaggedStruct<"InvalidRouteServerPeerId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteServerPeerIdNotFound extends InvalidRouteServerPeerIdNotFound_base {
 }
-declare const CannotDelete_base: S.ErrorClass<CannotDelete, S.TaggedStruct<"CannotDelete", {}>, import("effect/Cause").YieldableError>;
+declare const CannotDelete_base: S.Class<CannotDelete, S.TaggedStruct<"CannotDelete", {}>, import("effect/Cause").YieldableError>;
 export declare class CannotDelete extends CannotDelete_base {
 }
-declare const InvalidSnapshotIDMalformed_base: S.ErrorClass<InvalidSnapshotIDMalformed, S.TaggedStruct<"InvalidSnapshotID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSnapshotIDMalformed_base: S.Class<InvalidSnapshotIDMalformed, S.TaggedStruct<"InvalidSnapshotID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSnapshotIDMalformed extends InvalidSnapshotIDMalformed_base {
 }
-declare const InvalidSubnetIdMalformed_base: S.ErrorClass<InvalidSubnetIdMalformed, S.TaggedStruct<"InvalidSubnetId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetIdMalformed_base: S.Class<InvalidSubnetIdMalformed, S.TaggedStruct<"InvalidSubnetId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetIdMalformed extends InvalidSubnetIdMalformed_base {
 }
-declare const InvalidSubnetCidrReservationIDMalformed_base: S.ErrorClass<InvalidSubnetCidrReservationIDMalformed, S.TaggedStruct<"InvalidSubnetCidrReservationID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetCidrReservationIDMalformed_base: S.Class<InvalidSubnetCidrReservationIDMalformed, S.TaggedStruct<"InvalidSubnetCidrReservationID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetCidrReservationIDMalformed extends InvalidSubnetCidrReservationIDMalformed_base {
 }
-declare const InvalidSubnetCidrReservationIDNotFound_base: S.ErrorClass<InvalidSubnetCidrReservationIDNotFound, S.TaggedStruct<"InvalidSubnetCidrReservationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetCidrReservationIDNotFound_base: S.Class<InvalidSubnetCidrReservationIDNotFound, S.TaggedStruct<"InvalidSubnetCidrReservationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetCidrReservationIDNotFound extends InvalidSubnetCidrReservationIDNotFound_base {
 }
-declare const InvalidTrafficMirrorFilterIdNotFound_base: S.ErrorClass<InvalidTrafficMirrorFilterIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorFilterId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTrafficMirrorFilterIdNotFound_base: S.Class<InvalidTrafficMirrorFilterIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorFilterId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTrafficMirrorFilterIdNotFound extends InvalidTrafficMirrorFilterIdNotFound_base {
 }
-declare const InvalidTrafficMirrorFilterRuleIdNotFound_base: S.ErrorClass<InvalidTrafficMirrorFilterRuleIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorFilterRuleId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTrafficMirrorFilterRuleIdNotFound_base: S.Class<InvalidTrafficMirrorFilterRuleIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorFilterRuleId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTrafficMirrorFilterRuleIdNotFound extends InvalidTrafficMirrorFilterRuleIdNotFound_base {
 }
-declare const InvalidTrafficMirrorSessionIdNotFound_base: S.ErrorClass<InvalidTrafficMirrorSessionIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorSessionId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTrafficMirrorSessionIdNotFound_base: S.Class<InvalidTrafficMirrorSessionIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorSessionId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTrafficMirrorSessionIdNotFound extends InvalidTrafficMirrorSessionIdNotFound_base {
 }
-declare const InvalidTrafficMirrorTargetIdNotFound_base: S.ErrorClass<InvalidTrafficMirrorTargetIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorTargetId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTrafficMirrorTargetIdNotFound_base: S.Class<InvalidTrafficMirrorTargetIdNotFound, S.TaggedStruct<"InvalidTrafficMirrorTargetId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTrafficMirrorTargetIdNotFound extends InvalidTrafficMirrorTargetIdNotFound_base {
 }
-declare const InvalidTransitGatewayConnectPeerIDMalformed_base: S.ErrorClass<InvalidTransitGatewayConnectPeerIDMalformed, S.TaggedStruct<"InvalidTransitGatewayConnectPeerID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayConnectPeerIDMalformed_base: S.Class<InvalidTransitGatewayConnectPeerIDMalformed, S.TaggedStruct<"InvalidTransitGatewayConnectPeerID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayConnectPeerIDMalformed extends InvalidTransitGatewayConnectPeerIDMalformed_base {
 }
-declare const InvalidTransitGatewayConnectPeerIDNotFound_base: S.ErrorClass<InvalidTransitGatewayConnectPeerIDNotFound, S.TaggedStruct<"InvalidTransitGatewayConnectPeerID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayConnectPeerIDNotFound_base: S.Class<InvalidTransitGatewayConnectPeerIDNotFound, S.TaggedStruct<"InvalidTransitGatewayConnectPeerID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayConnectPeerIDNotFound extends InvalidTransitGatewayConnectPeerIDNotFound_base {
 }
-declare const InvalidTransitGatewayMeteringPolicyIdNotFound_base: S.ErrorClass<InvalidTransitGatewayMeteringPolicyIdNotFound, S.TaggedStruct<"InvalidTransitGatewayMeteringPolicyId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayMeteringPolicyIdNotFound_base: S.Class<InvalidTransitGatewayMeteringPolicyIdNotFound, S.TaggedStruct<"InvalidTransitGatewayMeteringPolicyId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayMeteringPolicyIdNotFound extends InvalidTransitGatewayMeteringPolicyIdNotFound_base {
 }
-declare const InvalidTransitGatewayMeteringPolicyIdMalformedException_base: S.ErrorClass<InvalidTransitGatewayMeteringPolicyIdMalformedException, S.TaggedStruct<"InvalidTransitGatewayMeteringPolicyIdMalformedException", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayMeteringPolicyIdMalformedException_base: S.Class<InvalidTransitGatewayMeteringPolicyIdMalformedException, S.TaggedStruct<"InvalidTransitGatewayMeteringPolicyIdMalformedException", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayMeteringPolicyIdMalformedException extends InvalidTransitGatewayMeteringPolicyIdMalformedException_base {
 }
-declare const InvalidTransitGatewayMulticastDomainIdMalformed_base: S.ErrorClass<InvalidTransitGatewayMulticastDomainIdMalformed, S.TaggedStruct<"InvalidTransitGatewayMulticastDomainId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayMulticastDomainIdMalformed_base: S.Class<InvalidTransitGatewayMulticastDomainIdMalformed, S.TaggedStruct<"InvalidTransitGatewayMulticastDomainId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayMulticastDomainIdMalformed extends InvalidTransitGatewayMulticastDomainIdMalformed_base {
 }
-declare const InvalidTransitGatewayRouteTableAnnouncementIdMalformed_base: S.ErrorClass<InvalidTransitGatewayRouteTableAnnouncementIdMalformed, S.TaggedStruct<"InvalidTransitGatewayRouteTableAnnouncementId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTransitGatewayRouteTableAnnouncementIdMalformed_base: S.Class<InvalidTransitGatewayRouteTableAnnouncementIdMalformed, S.TaggedStruct<"InvalidTransitGatewayRouteTableAnnouncementId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTransitGatewayRouteTableAnnouncementIdMalformed extends InvalidTransitGatewayRouteTableAnnouncementIdMalformed_base {
 }
-declare const InvalidVerifiedAccessEndpointIdNotFound_base: S.ErrorClass<InvalidVerifiedAccessEndpointIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVerifiedAccessEndpointIdNotFound_base: S.Class<InvalidVerifiedAccessEndpointIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessEndpointId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVerifiedAccessEndpointIdNotFound extends InvalidVerifiedAccessEndpointIdNotFound_base {
 }
-declare const InvalidVerifiedAccessGroupIdNotFound_base: S.ErrorClass<InvalidVerifiedAccessGroupIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessGroupId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVerifiedAccessGroupIdNotFound_base: S.Class<InvalidVerifiedAccessGroupIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessGroupId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVerifiedAccessGroupIdNotFound extends InvalidVerifiedAccessGroupIdNotFound_base {
 }
-declare const InvalidVerifiedAccessTrustProviderIdNotFound_base: S.ErrorClass<InvalidVerifiedAccessTrustProviderIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessTrustProviderId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVerifiedAccessTrustProviderIdNotFound_base: S.Class<InvalidVerifiedAccessTrustProviderIdNotFound, S.TaggedStruct<"InvalidVerifiedAccessTrustProviderId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVerifiedAccessTrustProviderIdNotFound extends InvalidVerifiedAccessTrustProviderIdNotFound_base {
 }
-declare const RequestError_base: S.ErrorClass<RequestError, S.TaggedStruct<"RequestError", {}>, import("effect/Cause").YieldableError>;
+declare const RequestError_base: S.Class<RequestError, S.TaggedStruct<"RequestError", {}>, import("effect/Cause").YieldableError>;
 export declare class RequestError extends RequestError_base {
 }
-declare const VpcBlockPublicAccessExclusionIdMalformed_base: S.ErrorClass<VpcBlockPublicAccessExclusionIdMalformed, S.TaggedStruct<"VpcBlockPublicAccessExclusionId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const VpcBlockPublicAccessExclusionIdMalformed_base: S.Class<VpcBlockPublicAccessExclusionIdMalformed, S.TaggedStruct<"VpcBlockPublicAccessExclusionId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class VpcBlockPublicAccessExclusionIdMalformed extends VpcBlockPublicAccessExclusionIdMalformed_base {
 }
-declare const InvalidVpcEncryptionControlIdMalformed_base: S.ErrorClass<InvalidVpcEncryptionControlIdMalformed, S.TaggedStruct<"InvalidVpcEncryptionControlId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcEncryptionControlIdMalformed_base: S.Class<InvalidVpcEncryptionControlIdMalformed, S.TaggedStruct<"InvalidVpcEncryptionControlId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcEncryptionControlIdMalformed extends InvalidVpcEncryptionControlIdMalformed_base {
 }
-declare const InvalidVpcEncryptionControlIdNotFound_base: S.ErrorClass<InvalidVpcEncryptionControlIdNotFound, S.TaggedStruct<"InvalidVpcEncryptionControlId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcEncryptionControlIdNotFound_base: S.Class<InvalidVpcEncryptionControlIdNotFound, S.TaggedStruct<"InvalidVpcEncryptionControlId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcEncryptionControlIdNotFound extends InvalidVpcEncryptionControlIdNotFound_base {
 }
-declare const InvalidVpnConcentratorIDMalformed_base: S.ErrorClass<InvalidVpnConcentratorIDMalformed, S.TaggedStruct<"InvalidVpnConcentratorID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnConcentratorIDMalformed_base: S.Class<InvalidVpnConcentratorIDMalformed, S.TaggedStruct<"InvalidVpnConcentratorID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnConcentratorIDMalformed extends InvalidVpnConcentratorIDMalformed_base {
 }
-declare const InvalidVpnConnectionIDNotFound_base: S.ErrorClass<InvalidVpnConnectionIDNotFound, S.TaggedStruct<"InvalidVpnConnectionID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnConnectionIDNotFound_base: S.Class<InvalidVpnConnectionIDNotFound, S.TaggedStruct<"InvalidVpnConnectionID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnConnectionIDNotFound extends InvalidVpnConnectionIDNotFound_base {
 }
-declare const InvalidRouteMalformed_base: S.ErrorClass<InvalidRouteMalformed, S.TaggedStruct<"InvalidRoute.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteMalformed_base: S.Class<InvalidRouteMalformed, S.TaggedStruct<"InvalidRoute.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteMalformed extends InvalidRouteMalformed_base {
 }
-declare const InvalidCapacityBlockIdMalformed_base: S.ErrorClass<InvalidCapacityBlockIdMalformed, S.TaggedStruct<"InvalidCapacityBlockId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCapacityBlockIdMalformed_base: S.Class<InvalidCapacityBlockIdMalformed, S.TaggedStruct<"InvalidCapacityBlockId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCapacityBlockIdMalformed extends InvalidCapacityBlockIdMalformed_base {
 }
-declare const InvalidEgressOnlyInternetGatewayIdMalformed_base: S.ErrorClass<InvalidEgressOnlyInternetGatewayIdMalformed, S.TaggedStruct<"InvalidEgressOnlyInternetGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidEgressOnlyInternetGatewayIdMalformed_base: S.Class<InvalidEgressOnlyInternetGatewayIdMalformed, S.TaggedStruct<"InvalidEgressOnlyInternetGatewayId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidEgressOnlyInternetGatewayIdMalformed extends InvalidEgressOnlyInternetGatewayIdMalformed_base {
 }
-declare const UnsupportedOperation_base: S.ErrorClass<UnsupportedOperation, S.TaggedStruct<"UnsupportedOperation", {}>, import("effect/Cause").YieldableError>;
+declare const UnsupportedOperation_base: S.Class<UnsupportedOperation, S.TaggedStruct<"UnsupportedOperation", {}>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperation extends UnsupportedOperation_base {
 }
-declare const InvalidExportTaskIDMalformed_base: S.ErrorClass<InvalidExportTaskIDMalformed, S.TaggedStruct<"InvalidExportTaskID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidExportTaskIDMalformed_base: S.Class<InvalidExportTaskIDMalformed, S.TaggedStruct<"InvalidExportTaskID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidExportTaskIDMalformed extends InvalidExportTaskIDMalformed_base {
 }
-declare const InvalidFpgaImageIDNotFound_base: S.ErrorClass<InvalidFpgaImageIDNotFound, S.TaggedStruct<"InvalidFpgaImageID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidFpgaImageIDNotFound_base: S.Class<InvalidFpgaImageIDNotFound, S.TaggedStruct<"InvalidFpgaImageID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidFpgaImageIDNotFound extends InvalidFpgaImageIDNotFound_base {
 }
-declare const InvalidHostReservationOfferingIdMalformed_base: S.ErrorClass<InvalidHostReservationOfferingIdMalformed, S.TaggedStruct<"InvalidHostReservationOfferingId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidHostReservationOfferingIdMalformed_base: S.Class<InvalidHostReservationOfferingIdMalformed, S.TaggedStruct<"InvalidHostReservationOfferingId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidHostReservationOfferingIdMalformed extends InvalidHostReservationOfferingIdMalformed_base {
 }
-declare const InvalidHostIDMalformed_base: S.ErrorClass<InvalidHostIDMalformed, S.TaggedStruct<"InvalidHostID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidHostIDMalformed_base: S.Class<InvalidHostIDMalformed, S.TaggedStruct<"InvalidHostID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidHostIDMalformed extends InvalidHostIDMalformed_base {
 }
-declare const InvalidTargetArnUnknown_base: S.ErrorClass<InvalidTargetArnUnknown, S.TaggedStruct<"InvalidTargetArn.Unknown", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidTargetArnUnknown_base: S.Class<InvalidTargetArnUnknown, S.TaggedStruct<"InvalidTargetArn.Unknown", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetArnUnknown extends InvalidTargetArnUnknown_base {
 }
-declare const InvalidIpamResourceDiscoveryAssociationIdNotFound_base: S.ErrorClass<InvalidIpamResourceDiscoveryAssociationIdNotFound, S.TaggedStruct<"InvalidIpamResourceDiscoveryAssociationId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamResourceDiscoveryAssociationIdNotFound_base: S.Class<InvalidIpamResourceDiscoveryAssociationIdNotFound, S.TaggedStruct<"InvalidIpamResourceDiscoveryAssociationId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamResourceDiscoveryAssociationIdNotFound extends InvalidIpamResourceDiscoveryAssociationIdNotFound_base {
 }
-declare const InvalidIpv6PoolIDNotFound_base: S.ErrorClass<InvalidIpv6PoolIDNotFound, S.TaggedStruct<"InvalidIpv6PoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpv6PoolIDNotFound_base: S.Class<InvalidIpv6PoolIDNotFound, S.TaggedStruct<"InvalidIpv6PoolID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpv6PoolIDNotFound extends InvalidIpv6PoolIDNotFound_base {
 }
-declare const InvalidKeyPairNotFound_base: S.ErrorClass<InvalidKeyPairNotFound, S.TaggedStruct<"InvalidKeyPair.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidKeyPairNotFound_base: S.Class<InvalidKeyPairNotFound, S.TaggedStruct<"InvalidKeyPair.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidKeyPairNotFound extends InvalidKeyPairNotFound_base {
 }
-declare const InvalidLaunchTemplateIdMalformed_base: S.ErrorClass<InvalidLaunchTemplateIdMalformed, S.TaggedStruct<"InvalidLaunchTemplateId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidLaunchTemplateIdMalformed_base: S.Class<InvalidLaunchTemplateIdMalformed, S.TaggedStruct<"InvalidLaunchTemplateId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidLaunchTemplateIdMalformed extends InvalidLaunchTemplateIdMalformed_base {
 }
-declare const FilterLimitExceeded_base: S.ErrorClass<FilterLimitExceeded, S.TaggedStruct<"FilterLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const FilterLimitExceeded_base: S.Class<FilterLimitExceeded, S.TaggedStruct<"FilterLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class FilterLimitExceeded extends FilterLimitExceeded_base {
 }
-declare const InvalidOutpostLagIDMalformed_base: S.ErrorClass<InvalidOutpostLagIDMalformed, S.TaggedStruct<"InvalidOutpostLagID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidOutpostLagIDMalformed_base: S.Class<InvalidOutpostLagIDMalformed, S.TaggedStruct<"InvalidOutpostLagID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidOutpostLagIDMalformed extends InvalidOutpostLagIDMalformed_base {
 }
-declare const InvalidPrefixListIdNotFound_base: S.ErrorClass<InvalidPrefixListIdNotFound, S.TaggedStruct<"InvalidPrefixListId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPrefixListIdNotFound_base: S.Class<InvalidPrefixListIdNotFound, S.TaggedStruct<"InvalidPrefixListId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPrefixListIdNotFound extends InvalidPrefixListIdNotFound_base {
 }
-declare const InvalidSecurityGroupRuleIdNotFound_base: S.ErrorClass<InvalidSecurityGroupRuleIdNotFound, S.TaggedStruct<"InvalidSecurityGroupRuleId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSecurityGroupRuleIdNotFound_base: S.Class<InvalidSecurityGroupRuleIdNotFound, S.TaggedStruct<"InvalidSecurityGroupRuleId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSecurityGroupRuleIdNotFound extends InvalidSecurityGroupRuleIdNotFound_base {
 }
-declare const InvalidServiceLinkVirtualInterfaceIDMalformed_base: S.ErrorClass<InvalidServiceLinkVirtualInterfaceIDMalformed, S.TaggedStruct<"InvalidServiceLinkVirtualInterfaceID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidServiceLinkVirtualInterfaceIDMalformed_base: S.Class<InvalidServiceLinkVirtualInterfaceIDMalformed, S.TaggedStruct<"InvalidServiceLinkVirtualInterfaceID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidServiceLinkVirtualInterfaceIDMalformed extends InvalidServiceLinkVirtualInterfaceIDMalformed_base {
 }
-declare const InvalidUserIDMalformed_base: S.ErrorClass<InvalidUserIDMalformed, S.TaggedStruct<"InvalidUserID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidUserIDMalformed_base: S.Class<InvalidUserIDMalformed, S.TaggedStruct<"InvalidUserID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidUserIDMalformed extends InvalidUserIDMalformed_base {
 }
-declare const InvalidSpotDatafeedNotFound_base: S.ErrorClass<InvalidSpotDatafeedNotFound, S.TaggedStruct<"InvalidSpotDatafeed.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSpotDatafeedNotFound_base: S.Class<InvalidSpotDatafeedNotFound, S.TaggedStruct<"InvalidSpotDatafeed.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSpotDatafeedNotFound extends InvalidSpotDatafeedNotFound_base {
 }
-declare const InvalidConnectionNotification_base: S.ErrorClass<InvalidConnectionNotification, S.TaggedStruct<"InvalidConnectionNotification", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidConnectionNotification_base: S.Class<InvalidConnectionNotification, S.TaggedStruct<"InvalidConnectionNotification", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidConnectionNotification extends InvalidConnectionNotification_base {
 }
-declare const InvalidVpcEndpointServiceIdMalformed_base: S.ErrorClass<InvalidVpcEndpointServiceIdMalformed, S.TaggedStruct<"InvalidVpcEndpointServiceId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcEndpointServiceIdMalformed_base: S.Class<InvalidVpcEndpointServiceIdMalformed, S.TaggedStruct<"InvalidVpcEndpointServiceId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcEndpointServiceIdMalformed extends InvalidVpcEndpointServiceIdMalformed_base {
 }
-declare const InvalidVpnConcentratorIdMalformed_base: S.ErrorClass<InvalidVpnConcentratorIdMalformed, S.TaggedStruct<"InvalidVpnConcentratorId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnConcentratorIdMalformed_base: S.Class<InvalidVpnConcentratorIdMalformed, S.TaggedStruct<"InvalidVpnConcentratorId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnConcentratorIdMalformed extends InvalidVpnConcentratorIdMalformed_base {
 }
-declare const GatewayNotAttached_base: S.ErrorClass<GatewayNotAttached, S.TaggedStruct<"Gateway.NotAttached", {}>, import("effect/Cause").YieldableError>;
+declare const GatewayNotAttached_base: S.Class<GatewayNotAttached, S.TaggedStruct<"Gateway.NotAttached", {}>, import("effect/Cause").YieldableError>;
 export declare class GatewayNotAttached extends GatewayNotAttached_base {
 }
-declare const InvalidAttachmentIDNotFound_base: S.ErrorClass<InvalidAttachmentIDNotFound, S.TaggedStruct<"InvalidAttachmentID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAttachmentIDNotFound_base: S.Class<InvalidAttachmentIDNotFound, S.TaggedStruct<"InvalidAttachmentID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAttachmentIDNotFound extends InvalidAttachmentIDNotFound_base {
 }
-declare const InvalidNetworkInterfaceAttachmentIdMalformed_base: S.ErrorClass<InvalidNetworkInterfaceAttachmentIdMalformed, S.TaggedStruct<"InvalidNetworkInterfaceAttachmentId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidNetworkInterfaceAttachmentIdMalformed_base: S.Class<InvalidNetworkInterfaceAttachmentIdMalformed, S.TaggedStruct<"InvalidNetworkInterfaceAttachmentId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkInterfaceAttachmentIdMalformed extends InvalidNetworkInterfaceAttachmentIdMalformed_base {
 }
-declare const CapacityManagerDisabled_base: S.ErrorClass<CapacityManagerDisabled, S.TaggedStruct<"CapacityManager.Disabled", {}>, import("effect/Cause").YieldableError>;
+declare const CapacityManagerDisabled_base: S.Class<CapacityManagerDisabled, S.TaggedStruct<"CapacityManager.Disabled", {}>, import("effect/Cause").YieldableError>;
 export declare class CapacityManagerDisabled extends CapacityManagerDisabled_base {
 }
-declare const InvalidAssociationIDNotFound_base: S.ErrorClass<InvalidAssociationIDNotFound, S.TaggedStruct<"InvalidAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidAssociationIDNotFound_base: S.Class<InvalidAssociationIDNotFound, S.TaggedStruct<"InvalidAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidAssociationIDNotFound extends InvalidAssociationIDNotFound_base {
 }
-declare const InvalidIpamResourceDiscoveryAssociationIdMalformed_base: S.ErrorClass<InvalidIpamResourceDiscoveryAssociationIdMalformed, S.TaggedStruct<"InvalidIpamResourceDiscoveryAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamResourceDiscoveryAssociationIdMalformed_base: S.Class<InvalidIpamResourceDiscoveryAssociationIdMalformed, S.TaggedStruct<"InvalidIpamResourceDiscoveryAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamResourceDiscoveryAssociationIdMalformed extends InvalidIpamResourceDiscoveryAssociationIdMalformed_base {
 }
-declare const InvalidSubnetCidrBlockAssociationIDNotFound_base: S.ErrorClass<InvalidSubnetCidrBlockAssociationIDNotFound, S.TaggedStruct<"InvalidSubnetCidrBlockAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetCidrBlockAssociationIDNotFound_base: S.Class<InvalidSubnetCidrBlockAssociationIDNotFound, S.TaggedStruct<"InvalidSubnetCidrBlockAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetCidrBlockAssociationIDNotFound extends InvalidSubnetCidrBlockAssociationIDNotFound_base {
 }
-declare const InvalidSubnetCidrBlockAssociationIdMalformed_base: S.ErrorClass<InvalidSubnetCidrBlockAssociationIdMalformed, S.TaggedStruct<"InvalidSubnetCidrBlockAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSubnetCidrBlockAssociationIdMalformed_base: S.Class<InvalidSubnetCidrBlockAssociationIdMalformed, S.TaggedStruct<"InvalidSubnetCidrBlockAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnetCidrBlockAssociationIdMalformed extends InvalidSubnetCidrBlockAssociationIdMalformed_base {
 }
-declare const InvalidVpcCidrBlockAssociationIDNotFound_base: S.ErrorClass<InvalidVpcCidrBlockAssociationIDNotFound, S.TaggedStruct<"InvalidVpcCidrBlockAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcCidrBlockAssociationIDNotFound_base: S.Class<InvalidVpcCidrBlockAssociationIDNotFound, S.TaggedStruct<"InvalidVpcCidrBlockAssociationID.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcCidrBlockAssociationIDNotFound extends InvalidVpcCidrBlockAssociationIDNotFound_base {
 }
-declare const InvalidVpcCidrBlockAssociationIdMalformed_base: S.ErrorClass<InvalidVpcCidrBlockAssociationIdMalformed, S.TaggedStruct<"InvalidVpcCidrBlockAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcCidrBlockAssociationIdMalformed_base: S.Class<InvalidVpcCidrBlockAssociationIdMalformed, S.TaggedStruct<"InvalidVpcCidrBlockAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcCidrBlockAssociationIdMalformed extends InvalidVpcCidrBlockAssociationIdMalformed_base {
 }
-declare const InvalidVpcCidrBlockAssociationIdErrorNotFound_base: S.ErrorClass<InvalidVpcCidrBlockAssociationIdErrorNotFound, S.TaggedStruct<"InvalidVpcCidrBlockAssociationIdError.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpcCidrBlockAssociationIdErrorNotFound_base: S.Class<InvalidVpcCidrBlockAssociationIdErrorNotFound, S.TaggedStruct<"InvalidVpcCidrBlockAssociationIdError.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpcCidrBlockAssociationIdErrorNotFound extends InvalidVpcCidrBlockAssociationIdErrorNotFound_base {
 }
-declare const UnauthorizedOperation_base: S.ErrorClass<UnauthorizedOperation, S.TaggedStruct<"UnauthorizedOperation", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const UnauthorizedOperation_base: S.Class<UnauthorizedOperation, S.TaggedStruct<"UnauthorizedOperation", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class UnauthorizedOperation extends UnauthorizedOperation_base {
 }
-declare const InvalidIpv6PoolIDMalformed_base: S.ErrorClass<InvalidIpv6PoolIDMalformed, S.TaggedStruct<"InvalidIpv6PoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpv6PoolIDMalformed_base: S.Class<InvalidIpv6PoolIDMalformed, S.TaggedStruct<"InvalidIpv6PoolID.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpv6PoolIDMalformed extends InvalidIpv6PoolIDMalformed_base {
 }
-declare const InvalidVpnConnectionDeviceTypeIdNotFound_base: S.ErrorClass<InvalidVpnConnectionDeviceTypeIdNotFound, S.TaggedStruct<"InvalidVpnConnectionDeviceTypeId.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnConnectionDeviceTypeIdNotFound_base: S.Class<InvalidVpnConnectionDeviceTypeIdNotFound, S.TaggedStruct<"InvalidVpnConnectionDeviceTypeId.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnConnectionDeviceTypeIdNotFound extends InvalidVpnConnectionDeviceTypeIdNotFound_base {
 }
-declare const InvalidVpnConnectionId_base: S.ErrorClass<InvalidVpnConnectionId, S.TaggedStruct<"InvalidVpnConnectionId", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidVpnConnectionId_base: S.Class<InvalidVpnConnectionId, S.TaggedStruct<"InvalidVpnConnectionId", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidVpnConnectionId extends InvalidVpnConnectionId_base {
 }
-declare const MissingRequiredParameter_base: S.ErrorClass<MissingRequiredParameter, S.TaggedStruct<"MissingRequiredParameter", {}>, import("effect/Cause").YieldableError>;
+declare const MissingRequiredParameter_base: S.Class<MissingRequiredParameter, S.TaggedStruct<"MissingRequiredParameter", {}>, import("effect/Cause").YieldableError>;
 export declare class MissingRequiredParameter extends MissingRequiredParameter_base {
 }
-declare const InvalidInstanceEventWindowIdMalformed_base: S.ErrorClass<InvalidInstanceEventWindowIdMalformed, S.TaggedStruct<"InvalidInstanceEventWindowId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidInstanceEventWindowIdMalformed_base: S.Class<InvalidInstanceEventWindowIdMalformed, S.TaggedStruct<"InvalidInstanceEventWindowId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceEventWindowIdMalformed extends InvalidInstanceEventWindowIdMalformed_base {
 }
-declare const InvalidIpamScopeIdMalformed_base: S.ErrorClass<InvalidIpamScopeIdMalformed, S.TaggedStruct<"InvalidIpamScopeId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidIpamScopeIdMalformed_base: S.Class<InvalidIpamScopeIdMalformed, S.TaggedStruct<"InvalidIpamScopeId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidIpamScopeIdMalformed extends InvalidIpamScopeIdMalformed_base {
 }
-declare const UnknownResource_base: S.ErrorClass<UnknownResource, S.TaggedStruct<"UnknownResource", {}>, import("effect/Cause").YieldableError>;
+declare const UnknownResource_base: S.Class<UnknownResource, S.TaggedStruct<"UnknownResource", {}>, import("effect/Cause").YieldableError>;
 export declare class UnknownResource extends UnknownResource_base {
 }
-declare const InvalidPurchaseTokenMalformed_base: S.ErrorClass<InvalidPurchaseTokenMalformed, S.TaggedStruct<"InvalidPurchaseToken.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPurchaseTokenMalformed_base: S.Class<InvalidPurchaseTokenMalformed, S.TaggedStruct<"InvalidPurchaseToken.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPurchaseTokenMalformed extends InvalidPurchaseTokenMalformed_base {
 }
-declare const InvalidIPAddressInUse_base: S.ErrorClass<InvalidIPAddressInUse, S.TaggedStruct<"InvalidIPAddress.InUse", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const InvalidIPAddressInUse_base: S.Class<InvalidIPAddressInUse, S.TaggedStruct<"InvalidIPAddress.InUse", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         DependencyViolationError: true;
     };
 });
 export declare class InvalidIPAddressInUse extends InvalidIPAddressInUse_base {
 }
-declare const InvalidRouteTableAssociationIdMalformed_base: S.ErrorClass<InvalidRouteTableAssociationIdMalformed, S.TaggedStruct<"InvalidRouteTableAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidRouteTableAssociationIdMalformed_base: S.Class<InvalidRouteTableAssociationIdMalformed, S.TaggedStruct<"InvalidRouteTableAssociationId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidRouteTableAssociationIdMalformed extends InvalidRouteTableAssociationIdMalformed_base {
 }
-declare const InvalidPermissionNotFound_base: S.ErrorClass<InvalidPermissionNotFound, S.TaggedStruct<"InvalidPermission.NotFound", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPermissionNotFound_base: S.Class<InvalidPermissionNotFound, S.TaggedStruct<"InvalidPermission.NotFound", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPermissionNotFound extends InvalidPermissionNotFound_base {
 }
-declare const InvalidSecurityGroupRuleIdMalformed_base: S.ErrorClass<InvalidSecurityGroupRuleIdMalformed, S.TaggedStruct<"InvalidSecurityGroupRuleId.Malformed", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidSecurityGroupRuleIdMalformed_base: S.Class<InvalidSecurityGroupRuleIdMalformed, S.TaggedStruct<"InvalidSecurityGroupRuleId.Malformed", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidSecurityGroupRuleIdMalformed extends InvalidSecurityGroupRuleIdMalformed_base {
 }
-declare const UnknownParameter_base: S.ErrorClass<UnknownParameter, S.TaggedStruct<"UnknownParameter", {}>, import("effect/Cause").YieldableError>;
+declare const UnknownParameter_base: S.Class<UnknownParameter, S.TaggedStruct<"UnknownParameter", {}>, import("effect/Cause").YieldableError>;
 export declare class UnknownParameter extends UnknownParameter_base {
 }
-declare const InvalidScheduledInstance_base: S.ErrorClass<InvalidScheduledInstance, S.TaggedStruct<"InvalidScheduledInstance", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidScheduledInstance_base: S.Class<InvalidScheduledInstance, S.TaggedStruct<"InvalidScheduledInstance", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidScheduledInstance extends InvalidScheduledInstance_base {
 }
-declare const DeclarativePoliciesAccessDenied_base: S.ErrorClass<DeclarativePoliciesAccessDenied, S.TaggedStruct<"DeclarativePoliciesAccessDenied", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const DeclarativePoliciesAccessDenied_base: S.Class<DeclarativePoliciesAccessDenied, S.TaggedStruct<"DeclarativePoliciesAccessDenied", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AuthError: true;
     };
 });
 export declare class DeclarativePoliciesAccessDenied extends DeclarativePoliciesAccessDenied_base {
 }
-declare const IdempotentParameterMismatch_base: S.ErrorClass<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const IdempotentParameterMismatch_base: S.Class<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ConflictError: true;
     };