@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/ssm.d.ts

@@ -4570,37 +4570,37 @@ export declare const UpdateServiceSettingRequest: S.Schema<UpdateServiceSettingR
 export interface UpdateServiceSettingResult {
 }
 export declare const UpdateServiceSettingResult: S.Schema<UpdateServiceSettingResult>;
-declare const InternalServerError_base: S.ErrorClass<InternalServerError, S.TaggedStruct<"InternalServerError", {
+declare const InternalServerError_base: S.Class<InternalServerError, S.TaggedStruct<"InternalServerError", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServerError extends InternalServerError_base {
 }
-declare const InvalidResourceId_base: S.ErrorClass<InvalidResourceId, S.TaggedStruct<"InvalidResourceId", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidResourceId_base: S.Class<InvalidResourceId, S.TaggedStruct<"InvalidResourceId", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceId extends InvalidResourceId_base {
 }
-declare const InvalidResourceType_base: S.ErrorClass<InvalidResourceType, S.TaggedStruct<"InvalidResourceType", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidResourceType_base: S.Class<InvalidResourceType, S.TaggedStruct<"InvalidResourceType", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceType extends InvalidResourceType_base {
 }
-declare const TooManyTagsError_base: S.ErrorClass<TooManyTagsError, S.TaggedStruct<"TooManyTagsError", {}>, import("effect/Cause").YieldableError>;
+declare const TooManyTagsError_base: S.Class<TooManyTagsError, S.TaggedStruct<"TooManyTagsError", {}>, import("effect/Cause").YieldableError>;
 export declare class TooManyTagsError extends TooManyTagsError_base {
 }
-declare const TooManyUpdates_base: S.ErrorClass<TooManyUpdates, S.TaggedStruct<"TooManyUpdates", {
+declare const TooManyUpdates_base: S.Class<TooManyUpdates, S.TaggedStruct<"TooManyUpdates", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TooManyUpdates extends TooManyUpdates_base {
 }
-declare const OpsItemConflictException_base: S.ErrorClass<OpsItemConflictException, S.TaggedStruct<"OpsItemConflictException", {
+declare const OpsItemConflictException_base: S.Class<OpsItemConflictException, S.TaggedStruct<"OpsItemConflictException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsItemConflictException extends OpsItemConflictException_base {
 }
-declare const OpsItemInvalidParameterException_base: S.ErrorClass<OpsItemInvalidParameterException, S.TaggedStruct<"OpsItemInvalidParameterException", {
+declare const OpsItemInvalidParameterException_base: S.Class<OpsItemInvalidParameterException, S.TaggedStruct<"OpsItemInvalidParameterException", {
     readonly ParameterNames: S.optional<S.$Array<S.String>>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsItemInvalidParameterException extends OpsItemInvalidParameterException_base {
 }
-declare const OpsItemLimitExceededException_base: S.ErrorClass<OpsItemLimitExceededException, S.TaggedStruct<"OpsItemLimitExceededException", {
+declare const OpsItemLimitExceededException_base: S.Class<OpsItemLimitExceededException, S.TaggedStruct<"OpsItemLimitExceededException", {
     readonly ResourceTypes: S.optional<S.$Array<S.String>>;
     readonly Limit: S.optional<S.Number>;
     readonly LimitType: S.optional<S.String>;
@@ -4608,12 +4608,12 @@ declare const OpsItemLimitExceededException_base: S.ErrorClass<OpsItemLimitExcee
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsItemLimitExceededException extends OpsItemLimitExceededException_base {
 }
-declare const OpsItemNotFoundException_base: S.ErrorClass<OpsItemNotFoundException, S.TaggedStruct<"OpsItemNotFoundException", {
+declare const OpsItemNotFoundException_base: S.Class<OpsItemNotFoundException, S.TaggedStruct<"OpsItemNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsItemNotFoundException extends OpsItemNotFoundException_base {
 }
-declare const OpsItemRelatedItemAlreadyExistsException_base: S.ErrorClass<OpsItemRelatedItemAlreadyExistsException, S.TaggedStruct<"OpsItemRelatedItemAlreadyExistsException", {
+declare const OpsItemRelatedItemAlreadyExistsException_base: S.Class<OpsItemRelatedItemAlreadyExistsException, S.TaggedStruct<"OpsItemRelatedItemAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceUri: S.optional<S.String>;
     readonly OpsItemId: S.optional<S.String>;
@@ -4624,80 +4624,80 @@ declare const OpsItemRelatedItemAlreadyExistsException_base: S.ErrorClass<OpsIte
 });
 export declare class OpsItemRelatedItemAlreadyExistsException extends OpsItemRelatedItemAlreadyExistsException_base {
 }
-declare const DuplicateInstanceId_base: S.ErrorClass<DuplicateInstanceId, S.TaggedStruct<"DuplicateInstanceId", {}>, import("effect/Cause").YieldableError>;
+declare const DuplicateInstanceId_base: S.Class<DuplicateInstanceId, S.TaggedStruct<"DuplicateInstanceId", {}>, import("effect/Cause").YieldableError>;
 export declare class DuplicateInstanceId extends DuplicateInstanceId_base {
 }
-declare const InvalidCommandId_base: S.ErrorClass<InvalidCommandId, S.TaggedStruct<"InvalidCommandId", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidCommandId_base: S.Class<InvalidCommandId, S.TaggedStruct<"InvalidCommandId", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidCommandId extends InvalidCommandId_base {
 }
-declare const InvalidInstanceId_base: S.ErrorClass<InvalidInstanceId, S.TaggedStruct<"InvalidInstanceId", {
+declare const InvalidInstanceId_base: S.Class<InvalidInstanceId, S.TaggedStruct<"InvalidInstanceId", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceId extends InvalidInstanceId_base {
 }
-declare const DoesNotExistException_base: S.ErrorClass<DoesNotExistException, S.TaggedStruct<"DoesNotExistException", {
+declare const DoesNotExistException_base: S.Class<DoesNotExistException, S.TaggedStruct<"DoesNotExistException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DoesNotExistException extends DoesNotExistException_base {
 }
-declare const InvalidParameters_base: S.ErrorClass<InvalidParameters, S.TaggedStruct<"InvalidParameters", {
+declare const InvalidParameters_base: S.Class<InvalidParameters, S.TaggedStruct<"InvalidParameters", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameters extends InvalidParameters_base {
 }
-declare const AssociationAlreadyExists_base: S.ErrorClass<AssociationAlreadyExists, S.TaggedStruct<"AssociationAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const AssociationAlreadyExists_base: S.Class<AssociationAlreadyExists, S.TaggedStruct<"AssociationAlreadyExists", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         AlreadyExistsError: true;
     };
 });
 export declare class AssociationAlreadyExists extends AssociationAlreadyExists_base {
 }
-declare const AssociationLimitExceeded_base: S.ErrorClass<AssociationLimitExceeded, S.TaggedStruct<"AssociationLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+declare const AssociationLimitExceeded_base: S.Class<AssociationLimitExceeded, S.TaggedStruct<"AssociationLimitExceeded", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
         ThrottlingError: true;
     };
 });
 export declare class AssociationLimitExceeded extends AssociationLimitExceeded_base {
 }
-declare const InvalidDocument_base: S.ErrorClass<InvalidDocument, S.TaggedStruct<"InvalidDocument", {
+declare const InvalidDocument_base: S.Class<InvalidDocument, S.TaggedStruct<"InvalidDocument", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocument extends InvalidDocument_base {
 }
-declare const InvalidDocumentVersion_base: S.ErrorClass<InvalidDocumentVersion, S.TaggedStruct<"InvalidDocumentVersion", {
+declare const InvalidDocumentVersion_base: S.Class<InvalidDocumentVersion, S.TaggedStruct<"InvalidDocumentVersion", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocumentVersion extends InvalidDocumentVersion_base {
 }
-declare const InvalidOutputLocation_base: S.ErrorClass<InvalidOutputLocation, S.TaggedStruct<"InvalidOutputLocation", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidOutputLocation_base: S.Class<InvalidOutputLocation, S.TaggedStruct<"InvalidOutputLocation", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidOutputLocation extends InvalidOutputLocation_base {
 }
-declare const InvalidSchedule_base: S.ErrorClass<InvalidSchedule, S.TaggedStruct<"InvalidSchedule", {
+declare const InvalidSchedule_base: S.Class<InvalidSchedule, S.TaggedStruct<"InvalidSchedule", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSchedule extends InvalidSchedule_base {
 }
-declare const InvalidTag_base: S.ErrorClass<InvalidTag, S.TaggedStruct<"InvalidTag", {
+declare const InvalidTag_base: S.Class<InvalidTag, S.TaggedStruct<"InvalidTag", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTag extends InvalidTag_base {
 }
-declare const InvalidTarget_base: S.ErrorClass<InvalidTarget, S.TaggedStruct<"InvalidTarget", {
+declare const InvalidTarget_base: S.Class<InvalidTarget, S.TaggedStruct<"InvalidTarget", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTarget extends InvalidTarget_base {
 }
-declare const InvalidTargetMaps_base: S.ErrorClass<InvalidTargetMaps, S.TaggedStruct<"InvalidTargetMaps", {
+declare const InvalidTargetMaps_base: S.Class<InvalidTargetMaps, S.TaggedStruct<"InvalidTargetMaps", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetMaps extends InvalidTargetMaps_base {
 }
-declare const UnsupportedPlatformType_base: S.ErrorClass<UnsupportedPlatformType, S.TaggedStruct<"UnsupportedPlatformType", {
+declare const UnsupportedPlatformType_base: S.Class<UnsupportedPlatformType, S.TaggedStruct<"UnsupportedPlatformType", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedPlatformType extends UnsupportedPlatformType_base {
 }
-declare const DocumentAlreadyExists_base: S.ErrorClass<DocumentAlreadyExists, S.TaggedStruct<"DocumentAlreadyExists", {
+declare const DocumentAlreadyExists_base: S.Class<DocumentAlreadyExists, S.TaggedStruct<"DocumentAlreadyExists", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4706,7 +4706,7 @@ declare const DocumentAlreadyExists_base: S.ErrorClass<DocumentAlreadyExists, S.
 });
 export declare class DocumentAlreadyExists extends DocumentAlreadyExists_base {
 }
-declare const DocumentLimitExceeded_base: S.ErrorClass<DocumentLimitExceeded, S.TaggedStruct<"DocumentLimitExceeded", {
+declare const DocumentLimitExceeded_base: S.Class<DocumentLimitExceeded, S.TaggedStruct<"DocumentLimitExceeded", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4715,27 +4715,27 @@ declare const DocumentLimitExceeded_base: S.ErrorClass<DocumentLimitExceeded, S.
 });
 export declare class DocumentLimitExceeded extends DocumentLimitExceeded_base {
 }
-declare const InvalidDocumentContent_base: S.ErrorClass<InvalidDocumentContent, S.TaggedStruct<"InvalidDocumentContent", {
+declare const InvalidDocumentContent_base: S.Class<InvalidDocumentContent, S.TaggedStruct<"InvalidDocumentContent", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocumentContent extends InvalidDocumentContent_base {
 }
-declare const InvalidDocumentSchemaVersion_base: S.ErrorClass<InvalidDocumentSchemaVersion, S.TaggedStruct<"InvalidDocumentSchemaVersion", {
+declare const InvalidDocumentSchemaVersion_base: S.Class<InvalidDocumentSchemaVersion, S.TaggedStruct<"InvalidDocumentSchemaVersion", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocumentSchemaVersion extends InvalidDocumentSchemaVersion_base {
 }
-declare const MaxDocumentSizeExceeded_base: S.ErrorClass<MaxDocumentSizeExceeded, S.TaggedStruct<"MaxDocumentSizeExceeded", {
+declare const MaxDocumentSizeExceeded_base: S.Class<MaxDocumentSizeExceeded, S.TaggedStruct<"MaxDocumentSizeExceeded", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxDocumentSizeExceeded extends MaxDocumentSizeExceeded_base {
 }
-declare const NoLongerSupportedException_base: S.ErrorClass<NoLongerSupportedException, S.TaggedStruct<"NoLongerSupportedException", {
+declare const NoLongerSupportedException_base: S.Class<NoLongerSupportedException, S.TaggedStruct<"NoLongerSupportedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoLongerSupportedException extends NoLongerSupportedException_base {
 }
-declare const IdempotentParameterMismatch_base: S.ErrorClass<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {
+declare const IdempotentParameterMismatch_base: S.Class<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4744,12 +4744,12 @@ declare const IdempotentParameterMismatch_base: S.ErrorClass<IdempotentParameter
 });
 export declare class IdempotentParameterMismatch extends IdempotentParameterMismatch_base {
 }
-declare const ResourceLimitExceededException_base: S.ErrorClass<ResourceLimitExceededException, S.TaggedStruct<"ResourceLimitExceededException", {
+declare const ResourceLimitExceededException_base: S.Class<ResourceLimitExceededException, S.TaggedStruct<"ResourceLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceLimitExceededException extends ResourceLimitExceededException_base {
 }
-declare const OpsItemAccessDeniedException_base: S.ErrorClass<OpsItemAccessDeniedException, S.TaggedStruct<"OpsItemAccessDeniedException", {
+declare const OpsItemAccessDeniedException_base: S.Class<OpsItemAccessDeniedException, S.TaggedStruct<"OpsItemAccessDeniedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4758,7 +4758,7 @@ declare const OpsItemAccessDeniedException_base: S.ErrorClass<OpsItemAccessDenie
 });
 export declare class OpsItemAccessDeniedException extends OpsItemAccessDeniedException_base {
 }
-declare const OpsItemAlreadyExistsException_base: S.ErrorClass<OpsItemAlreadyExistsException, S.TaggedStruct<"OpsItemAlreadyExistsException", {
+declare const OpsItemAlreadyExistsException_base: S.Class<OpsItemAlreadyExistsException, S.TaggedStruct<"OpsItemAlreadyExistsException", {
     readonly Message: S.optional<S.String>;
     readonly OpsItemId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -4768,7 +4768,7 @@ declare const OpsItemAlreadyExistsException_base: S.ErrorClass<OpsItemAlreadyExi
 });
 export declare class OpsItemAlreadyExistsException extends OpsItemAlreadyExistsException_base {
 }
-declare const OpsMetadataAlreadyExistsException_base: S.ErrorClass<OpsMetadataAlreadyExistsException, S.TaggedStruct<"OpsMetadataAlreadyExistsException", {
+declare const OpsMetadataAlreadyExistsException_base: S.Class<OpsMetadataAlreadyExistsException, S.TaggedStruct<"OpsMetadataAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4777,22 +4777,22 @@ declare const OpsMetadataAlreadyExistsException_base: S.ErrorClass<OpsMetadataAl
 });
 export declare class OpsMetadataAlreadyExistsException extends OpsMetadataAlreadyExistsException_base {
 }
-declare const OpsMetadataInvalidArgumentException_base: S.ErrorClass<OpsMetadataInvalidArgumentException, S.TaggedStruct<"OpsMetadataInvalidArgumentException", {
+declare const OpsMetadataInvalidArgumentException_base: S.Class<OpsMetadataInvalidArgumentException, S.TaggedStruct<"OpsMetadataInvalidArgumentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsMetadataInvalidArgumentException extends OpsMetadataInvalidArgumentException_base {
 }
-declare const OpsMetadataLimitExceededException_base: S.ErrorClass<OpsMetadataLimitExceededException, S.TaggedStruct<"OpsMetadataLimitExceededException", {
+declare const OpsMetadataLimitExceededException_base: S.Class<OpsMetadataLimitExceededException, S.TaggedStruct<"OpsMetadataLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsMetadataLimitExceededException extends OpsMetadataLimitExceededException_base {
 }
-declare const OpsMetadataTooManyUpdatesException_base: S.ErrorClass<OpsMetadataTooManyUpdatesException, S.TaggedStruct<"OpsMetadataTooManyUpdatesException", {
+declare const OpsMetadataTooManyUpdatesException_base: S.Class<OpsMetadataTooManyUpdatesException, S.TaggedStruct<"OpsMetadataTooManyUpdatesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsMetadataTooManyUpdatesException extends OpsMetadataTooManyUpdatesException_base {
 }
-declare const ResourceDataSyncAlreadyExistsException_base: S.ErrorClass<ResourceDataSyncAlreadyExistsException, S.TaggedStruct<"ResourceDataSyncAlreadyExistsException", {
+declare const ResourceDataSyncAlreadyExistsException_base: S.Class<ResourceDataSyncAlreadyExistsException, S.TaggedStruct<"ResourceDataSyncAlreadyExistsException", {
     readonly SyncName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4801,181 +4801,181 @@ declare const ResourceDataSyncAlreadyExistsException_base: S.ErrorClass<Resource
 });
 export declare class ResourceDataSyncAlreadyExistsException extends ResourceDataSyncAlreadyExistsException_base {
 }
-declare const ResourceDataSyncCountExceededException_base: S.ErrorClass<ResourceDataSyncCountExceededException, S.TaggedStruct<"ResourceDataSyncCountExceededException", {
+declare const ResourceDataSyncCountExceededException_base: S.Class<ResourceDataSyncCountExceededException, S.TaggedStruct<"ResourceDataSyncCountExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceDataSyncCountExceededException extends ResourceDataSyncCountExceededException_base {
 }
-declare const ResourceDataSyncInvalidConfigurationException_base: S.ErrorClass<ResourceDataSyncInvalidConfigurationException, S.TaggedStruct<"ResourceDataSyncInvalidConfigurationException", {
+declare const ResourceDataSyncInvalidConfigurationException_base: S.Class<ResourceDataSyncInvalidConfigurationException, S.TaggedStruct<"ResourceDataSyncInvalidConfigurationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceDataSyncInvalidConfigurationException extends ResourceDataSyncInvalidConfigurationException_base {
 }
-declare const InvalidActivation_base: S.ErrorClass<InvalidActivation, S.TaggedStruct<"InvalidActivation", {
+declare const InvalidActivation_base: S.Class<InvalidActivation, S.TaggedStruct<"InvalidActivation", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidActivation extends InvalidActivation_base {
 }
-declare const InvalidActivationId_base: S.ErrorClass<InvalidActivationId, S.TaggedStruct<"InvalidActivationId", {
+declare const InvalidActivationId_base: S.Class<InvalidActivationId, S.TaggedStruct<"InvalidActivationId", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidActivationId extends InvalidActivationId_base {
 }
-declare const AssociationDoesNotExist_base: S.ErrorClass<AssociationDoesNotExist, S.TaggedStruct<"AssociationDoesNotExist", {
+declare const AssociationDoesNotExist_base: S.Class<AssociationDoesNotExist, S.TaggedStruct<"AssociationDoesNotExist", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AssociationDoesNotExist extends AssociationDoesNotExist_base {
 }
-declare const AssociatedInstances_base: S.ErrorClass<AssociatedInstances, S.TaggedStruct<"AssociatedInstances", {}>, import("effect/Cause").YieldableError>;
+declare const AssociatedInstances_base: S.Class<AssociatedInstances, S.TaggedStruct<"AssociatedInstances", {}>, import("effect/Cause").YieldableError>;
 export declare class AssociatedInstances extends AssociatedInstances_base {
 }
-declare const InvalidDocumentOperation_base: S.ErrorClass<InvalidDocumentOperation, S.TaggedStruct<"InvalidDocumentOperation", {
+declare const InvalidDocumentOperation_base: S.Class<InvalidDocumentOperation, S.TaggedStruct<"InvalidDocumentOperation", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocumentOperation extends InvalidDocumentOperation_base {
 }
-declare const InvalidDeleteInventoryParametersException_base: S.ErrorClass<InvalidDeleteInventoryParametersException, S.TaggedStruct<"InvalidDeleteInventoryParametersException", {
+declare const InvalidDeleteInventoryParametersException_base: S.Class<InvalidDeleteInventoryParametersException, S.TaggedStruct<"InvalidDeleteInventoryParametersException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeleteInventoryParametersException extends InvalidDeleteInventoryParametersException_base {
 }
-declare const InvalidInventoryRequestException_base: S.ErrorClass<InvalidInventoryRequestException, S.TaggedStruct<"InvalidInventoryRequestException", {
+declare const InvalidInventoryRequestException_base: S.Class<InvalidInventoryRequestException, S.TaggedStruct<"InvalidInventoryRequestException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInventoryRequestException extends InvalidInventoryRequestException_base {
 }
-declare const InvalidOptionException_base: S.ErrorClass<InvalidOptionException, S.TaggedStruct<"InvalidOptionException", {
+declare const InvalidOptionException_base: S.Class<InvalidOptionException, S.TaggedStruct<"InvalidOptionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOptionException extends InvalidOptionException_base {
 }
-declare const InvalidTypeNameException_base: S.ErrorClass<InvalidTypeNameException, S.TaggedStruct<"InvalidTypeNameException", {
+declare const InvalidTypeNameException_base: S.Class<InvalidTypeNameException, S.TaggedStruct<"InvalidTypeNameException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTypeNameException extends InvalidTypeNameException_base {
 }
-declare const OpsMetadataNotFoundException_base: S.ErrorClass<OpsMetadataNotFoundException, S.TaggedStruct<"OpsMetadataNotFoundException", {
+declare const OpsMetadataNotFoundException_base: S.Class<OpsMetadataNotFoundException, S.TaggedStruct<"OpsMetadataNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsMetadataNotFoundException extends OpsMetadataNotFoundException_base {
 }
-declare const ParameterNotFound_base: S.ErrorClass<ParameterNotFound, S.TaggedStruct<"ParameterNotFound", {
+declare const ParameterNotFound_base: S.Class<ParameterNotFound, S.TaggedStruct<"ParameterNotFound", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParameterNotFound extends ParameterNotFound_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const ResourceDataSyncNotFoundException_base: S.ErrorClass<ResourceDataSyncNotFoundException, S.TaggedStruct<"ResourceDataSyncNotFoundException", {
+declare const ResourceDataSyncNotFoundException_base: S.Class<ResourceDataSyncNotFoundException, S.TaggedStruct<"ResourceDataSyncNotFoundException", {
     readonly SyncName: S.optional<S.String>;
     readonly SyncType: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceDataSyncNotFoundException extends ResourceDataSyncNotFoundException_base {
 }
-declare const MalformedResourcePolicyDocumentException_base: S.ErrorClass<MalformedResourcePolicyDocumentException, S.TaggedStruct<"MalformedResourcePolicyDocumentException", {
+declare const MalformedResourcePolicyDocumentException_base: S.Class<MalformedResourcePolicyDocumentException, S.TaggedStruct<"MalformedResourcePolicyDocumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MalformedResourcePolicyDocumentException extends MalformedResourcePolicyDocumentException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ResourcePolicyConflictException_base: S.ErrorClass<ResourcePolicyConflictException, S.TaggedStruct<"ResourcePolicyConflictException", {
+declare const ResourcePolicyConflictException_base: S.Class<ResourcePolicyConflictException, S.TaggedStruct<"ResourcePolicyConflictException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourcePolicyConflictException extends ResourcePolicyConflictException_base {
 }
-declare const ResourcePolicyInvalidParameterException_base: S.ErrorClass<ResourcePolicyInvalidParameterException, S.TaggedStruct<"ResourcePolicyInvalidParameterException", {
+declare const ResourcePolicyInvalidParameterException_base: S.Class<ResourcePolicyInvalidParameterException, S.TaggedStruct<"ResourcePolicyInvalidParameterException", {
     readonly ParameterNames: S.optional<S.$Array<S.String>>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourcePolicyInvalidParameterException extends ResourcePolicyInvalidParameterException_base {
 }
-declare const ResourcePolicyNotFoundException_base: S.ErrorClass<ResourcePolicyNotFoundException, S.TaggedStruct<"ResourcePolicyNotFoundException", {
+declare const ResourcePolicyNotFoundException_base: S.Class<ResourcePolicyNotFoundException, S.TaggedStruct<"ResourcePolicyNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourcePolicyNotFoundException extends ResourcePolicyNotFoundException_base {
 }
-declare const TargetInUseException_base: S.ErrorClass<TargetInUseException, S.TaggedStruct<"TargetInUseException", {
+declare const TargetInUseException_base: S.Class<TargetInUseException, S.TaggedStruct<"TargetInUseException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetInUseException extends TargetInUseException_base {
 }
-declare const InvalidFilter_base: S.ErrorClass<InvalidFilter, S.TaggedStruct<"InvalidFilter", {
+declare const InvalidFilter_base: S.Class<InvalidFilter, S.TaggedStruct<"InvalidFilter", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFilter extends InvalidFilter_base {
 }
-declare const InvalidNextToken_base: S.ErrorClass<InvalidNextToken, S.TaggedStruct<"InvalidNextToken", {
+declare const InvalidNextToken_base: S.Class<InvalidNextToken, S.TaggedStruct<"InvalidNextToken", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNextToken extends InvalidNextToken_base {
 }
-declare const InvalidAssociationVersion_base: S.ErrorClass<InvalidAssociationVersion, S.TaggedStruct<"InvalidAssociationVersion", {
+declare const InvalidAssociationVersion_base: S.Class<InvalidAssociationVersion, S.TaggedStruct<"InvalidAssociationVersion", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAssociationVersion extends InvalidAssociationVersion_base {
 }
-declare const AssociationExecutionDoesNotExist_base: S.ErrorClass<AssociationExecutionDoesNotExist, S.TaggedStruct<"AssociationExecutionDoesNotExist", {
+declare const AssociationExecutionDoesNotExist_base: S.Class<AssociationExecutionDoesNotExist, S.TaggedStruct<"AssociationExecutionDoesNotExist", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AssociationExecutionDoesNotExist extends AssociationExecutionDoesNotExist_base {
 }
-declare const InvalidFilterKey_base: S.ErrorClass<InvalidFilterKey, S.TaggedStruct<"InvalidFilterKey", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidFilterKey_base: S.Class<InvalidFilterKey, S.TaggedStruct<"InvalidFilterKey", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidFilterKey extends InvalidFilterKey_base {
 }
-declare const InvalidFilterValue_base: S.ErrorClass<InvalidFilterValue, S.TaggedStruct<"InvalidFilterValue", {
+declare const InvalidFilterValue_base: S.Class<InvalidFilterValue, S.TaggedStruct<"InvalidFilterValue", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFilterValue extends InvalidFilterValue_base {
 }
-declare const AutomationExecutionNotFoundException_base: S.ErrorClass<AutomationExecutionNotFoundException, S.TaggedStruct<"AutomationExecutionNotFoundException", {
+declare const AutomationExecutionNotFoundException_base: S.Class<AutomationExecutionNotFoundException, S.TaggedStruct<"AutomationExecutionNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationExecutionNotFoundException extends AutomationExecutionNotFoundException_base {
 }
-declare const InvalidPermissionType_base: S.ErrorClass<InvalidPermissionType, S.TaggedStruct<"InvalidPermissionType", {
+declare const InvalidPermissionType_base: S.Class<InvalidPermissionType, S.TaggedStruct<"InvalidPermissionType", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPermissionType extends InvalidPermissionType_base {
 }
-declare const UnsupportedOperatingSystem_base: S.ErrorClass<UnsupportedOperatingSystem, S.TaggedStruct<"UnsupportedOperatingSystem", {
+declare const UnsupportedOperatingSystem_base: S.Class<UnsupportedOperatingSystem, S.TaggedStruct<"UnsupportedOperatingSystem", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperatingSystem extends UnsupportedOperatingSystem_base {
 }
-declare const InvalidInstanceInformationFilterValue_base: S.ErrorClass<InvalidInstanceInformationFilterValue, S.TaggedStruct<"InvalidInstanceInformationFilterValue", {
+declare const InvalidInstanceInformationFilterValue_base: S.Class<InvalidInstanceInformationFilterValue, S.TaggedStruct<"InvalidInstanceInformationFilterValue", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstanceInformationFilterValue extends InvalidInstanceInformationFilterValue_base {
 }
-declare const InvalidInstancePropertyFilterValue_base: S.ErrorClass<InvalidInstancePropertyFilterValue, S.TaggedStruct<"InvalidInstancePropertyFilterValue", {
+declare const InvalidInstancePropertyFilterValue_base: S.Class<InvalidInstancePropertyFilterValue, S.TaggedStruct<"InvalidInstancePropertyFilterValue", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInstancePropertyFilterValue extends InvalidInstancePropertyFilterValue_base {
 }
-declare const InvalidDeletionIdException_base: S.ErrorClass<InvalidDeletionIdException, S.TaggedStruct<"InvalidDeletionIdException", {
+declare const InvalidDeletionIdException_base: S.Class<InvalidDeletionIdException, S.TaggedStruct<"InvalidDeletionIdException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeletionIdException extends InvalidDeletionIdException_base {
 }
-declare const InvalidFilterOption_base: S.ErrorClass<InvalidFilterOption, S.TaggedStruct<"InvalidFilterOption", {
+declare const InvalidFilterOption_base: S.Class<InvalidFilterOption, S.TaggedStruct<"InvalidFilterOption", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFilterOption extends InvalidFilterOption_base {
 }
-declare const OpsItemRelatedItemAssociationNotFoundException_base: S.ErrorClass<OpsItemRelatedItemAssociationNotFoundException, S.TaggedStruct<"OpsItemRelatedItemAssociationNotFoundException", {
+declare const OpsItemRelatedItemAssociationNotFoundException_base: S.Class<OpsItemRelatedItemAssociationNotFoundException, S.TaggedStruct<"OpsItemRelatedItemAssociationNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsItemRelatedItemAssociationNotFoundException extends OpsItemRelatedItemAssociationNotFoundException_base {
 }
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -4984,71 +4984,71 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.String;
     readonly QuotaCode: S.optional<S.String>;
     readonly ServiceCode: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly Message: S.optional<S.String>;
     readonly ReasonCode: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ValidationException extends ValidationException_base {
 }
-declare const InvalidDocumentType_base: S.ErrorClass<InvalidDocumentType, S.TaggedStruct<"InvalidDocumentType", {
+declare const InvalidDocumentType_base: S.Class<InvalidDocumentType, S.TaggedStruct<"InvalidDocumentType", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDocumentType extends InvalidDocumentType_base {
 }
-declare const UnsupportedCalendarException_base: S.ErrorClass<UnsupportedCalendarException, S.TaggedStruct<"UnsupportedCalendarException", {
+declare const UnsupportedCalendarException_base: S.Class<UnsupportedCalendarException, S.TaggedStruct<"UnsupportedCalendarException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedCalendarException extends UnsupportedCalendarException_base {
 }
-declare const InvalidPluginName_base: S.ErrorClass<InvalidPluginName, S.TaggedStruct<"InvalidPluginName", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidPluginName_base: S.Class<InvalidPluginName, S.TaggedStruct<"InvalidPluginName", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidPluginName extends InvalidPluginName_base {
 }
-declare const InvocationDoesNotExist_base: S.ErrorClass<InvocationDoesNotExist, S.TaggedStruct<"InvocationDoesNotExist", {}>, import("effect/Cause").YieldableError>;
+declare const InvocationDoesNotExist_base: S.Class<InvocationDoesNotExist, S.TaggedStruct<"InvocationDoesNotExist", {}>, import("effect/Cause").YieldableError>;
 export declare class InvocationDoesNotExist extends InvocationDoesNotExist_base {
 }
-declare const UnsupportedFeatureRequiredException_base: S.ErrorClass<UnsupportedFeatureRequiredException, S.TaggedStruct<"UnsupportedFeatureRequiredException", {
+declare const UnsupportedFeatureRequiredException_base: S.Class<UnsupportedFeatureRequiredException, S.TaggedStruct<"UnsupportedFeatureRequiredException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedFeatureRequiredException extends UnsupportedFeatureRequiredException_base {
 }
-declare const InvalidAggregatorException_base: S.ErrorClass<InvalidAggregatorException, S.TaggedStruct<"InvalidAggregatorException", {
+declare const InvalidAggregatorException_base: S.Class<InvalidAggregatorException, S.TaggedStruct<"InvalidAggregatorException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAggregatorException extends InvalidAggregatorException_base {
 }
-declare const InvalidInventoryGroupException_base: S.ErrorClass<InvalidInventoryGroupException, S.TaggedStruct<"InvalidInventoryGroupException", {
+declare const InvalidInventoryGroupException_base: S.Class<InvalidInventoryGroupException, S.TaggedStruct<"InvalidInventoryGroupException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInventoryGroupException extends InvalidInventoryGroupException_base {
 }
-declare const InvalidResultAttributeException_base: S.ErrorClass<InvalidResultAttributeException, S.TaggedStruct<"InvalidResultAttributeException", {
+declare const InvalidResultAttributeException_base: S.Class<InvalidResultAttributeException, S.TaggedStruct<"InvalidResultAttributeException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResultAttributeException extends InvalidResultAttributeException_base {
 }
-declare const InvalidKeyId_base: S.ErrorClass<InvalidKeyId, S.TaggedStruct<"InvalidKeyId", {
+declare const InvalidKeyId_base: S.Class<InvalidKeyId, S.TaggedStruct<"InvalidKeyId", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidKeyId extends InvalidKeyId_base {
 }
-declare const ParameterVersionNotFound_base: S.ErrorClass<ParameterVersionNotFound, S.TaggedStruct<"ParameterVersionNotFound", {
+declare const ParameterVersionNotFound_base: S.Class<ParameterVersionNotFound, S.TaggedStruct<"ParameterVersionNotFound", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParameterVersionNotFound extends ParameterVersionNotFound_base {
 }
-declare const ServiceSettingNotFound_base: S.ErrorClass<ServiceSettingNotFound, S.TaggedStruct<"ServiceSettingNotFound", {
+declare const ServiceSettingNotFound_base: S.Class<ServiceSettingNotFound, S.TaggedStruct<"ServiceSettingNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceSettingNotFound extends ServiceSettingNotFound_base {
 }
-declare const ParameterVersionLabelLimitExceeded_base: S.ErrorClass<ParameterVersionLabelLimitExceeded, S.TaggedStruct<"ParameterVersionLabelLimitExceeded", {
+declare const ParameterVersionLabelLimitExceeded_base: S.Class<ParameterVersionLabelLimitExceeded, S.TaggedStruct<"ParameterVersionLabelLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5057,101 +5057,101 @@ declare const ParameterVersionLabelLimitExceeded_base: S.ErrorClass<ParameterVer
 });
 export declare class ParameterVersionLabelLimitExceeded extends ParameterVersionLabelLimitExceeded_base {
 }
-declare const UnsupportedOperationException_base: S.ErrorClass<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
+declare const UnsupportedOperationException_base: S.Class<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperationException extends UnsupportedOperationException_base {
 }
-declare const DocumentPermissionLimit_base: S.ErrorClass<DocumentPermissionLimit, S.TaggedStruct<"DocumentPermissionLimit", {
+declare const DocumentPermissionLimit_base: S.Class<DocumentPermissionLimit, S.TaggedStruct<"DocumentPermissionLimit", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DocumentPermissionLimit extends DocumentPermissionLimit_base {
 }
-declare const ComplianceTypeCountLimitExceededException_base: S.ErrorClass<ComplianceTypeCountLimitExceededException, S.TaggedStruct<"ComplianceTypeCountLimitExceededException", {
+declare const ComplianceTypeCountLimitExceededException_base: S.Class<ComplianceTypeCountLimitExceededException, S.TaggedStruct<"ComplianceTypeCountLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ComplianceTypeCountLimitExceededException extends ComplianceTypeCountLimitExceededException_base {
 }
-declare const InvalidItemContentException_base: S.ErrorClass<InvalidItemContentException, S.TaggedStruct<"InvalidItemContentException", {
+declare const InvalidItemContentException_base: S.Class<InvalidItemContentException, S.TaggedStruct<"InvalidItemContentException", {
     readonly TypeName: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidItemContentException extends InvalidItemContentException_base {
 }
-declare const ItemSizeLimitExceededException_base: S.ErrorClass<ItemSizeLimitExceededException, S.TaggedStruct<"ItemSizeLimitExceededException", {
+declare const ItemSizeLimitExceededException_base: S.Class<ItemSizeLimitExceededException, S.TaggedStruct<"ItemSizeLimitExceededException", {
     readonly TypeName: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ItemSizeLimitExceededException extends ItemSizeLimitExceededException_base {
 }
-declare const TotalSizeLimitExceededException_base: S.ErrorClass<TotalSizeLimitExceededException, S.TaggedStruct<"TotalSizeLimitExceededException", {
+declare const TotalSizeLimitExceededException_base: S.Class<TotalSizeLimitExceededException, S.TaggedStruct<"TotalSizeLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TotalSizeLimitExceededException extends TotalSizeLimitExceededException_base {
 }
-declare const CustomSchemaCountLimitExceededException_base: S.ErrorClass<CustomSchemaCountLimitExceededException, S.TaggedStruct<"CustomSchemaCountLimitExceededException", {
+declare const CustomSchemaCountLimitExceededException_base: S.Class<CustomSchemaCountLimitExceededException, S.TaggedStruct<"CustomSchemaCountLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CustomSchemaCountLimitExceededException extends CustomSchemaCountLimitExceededException_base {
 }
-declare const InvalidInventoryItemContextException_base: S.ErrorClass<InvalidInventoryItemContextException, S.TaggedStruct<"InvalidInventoryItemContextException", {
+declare const InvalidInventoryItemContextException_base: S.Class<InvalidInventoryItemContextException, S.TaggedStruct<"InvalidInventoryItemContextException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidInventoryItemContextException extends InvalidInventoryItemContextException_base {
 }
-declare const ItemContentMismatchException_base: S.ErrorClass<ItemContentMismatchException, S.TaggedStruct<"ItemContentMismatchException", {
+declare const ItemContentMismatchException_base: S.Class<ItemContentMismatchException, S.TaggedStruct<"ItemContentMismatchException", {
     readonly TypeName: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ItemContentMismatchException extends ItemContentMismatchException_base {
 }
-declare const SubTypeCountLimitExceededException_base: S.ErrorClass<SubTypeCountLimitExceededException, S.TaggedStruct<"SubTypeCountLimitExceededException", {
+declare const SubTypeCountLimitExceededException_base: S.Class<SubTypeCountLimitExceededException, S.TaggedStruct<"SubTypeCountLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SubTypeCountLimitExceededException extends SubTypeCountLimitExceededException_base {
 }
-declare const UnsupportedInventoryItemContextException_base: S.ErrorClass<UnsupportedInventoryItemContextException, S.TaggedStruct<"UnsupportedInventoryItemContextException", {
+declare const UnsupportedInventoryItemContextException_base: S.Class<UnsupportedInventoryItemContextException, S.TaggedStruct<"UnsupportedInventoryItemContextException", {
     readonly TypeName: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedInventoryItemContextException extends UnsupportedInventoryItemContextException_base {
 }
-declare const UnsupportedInventorySchemaVersionException_base: S.ErrorClass<UnsupportedInventorySchemaVersionException, S.TaggedStruct<"UnsupportedInventorySchemaVersionException", {
+declare const UnsupportedInventorySchemaVersionException_base: S.Class<UnsupportedInventorySchemaVersionException, S.TaggedStruct<"UnsupportedInventorySchemaVersionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedInventorySchemaVersionException extends UnsupportedInventorySchemaVersionException_base {
 }
-declare const HierarchyLevelLimitExceededException_base: S.ErrorClass<HierarchyLevelLimitExceededException, S.TaggedStruct<"HierarchyLevelLimitExceededException", {
+declare const HierarchyLevelLimitExceededException_base: S.Class<HierarchyLevelLimitExceededException, S.TaggedStruct<"HierarchyLevelLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class HierarchyLevelLimitExceededException extends HierarchyLevelLimitExceededException_base {
 }
-declare const HierarchyTypeMismatchException_base: S.ErrorClass<HierarchyTypeMismatchException, S.TaggedStruct<"HierarchyTypeMismatchException", {
+declare const HierarchyTypeMismatchException_base: S.Class<HierarchyTypeMismatchException, S.TaggedStruct<"HierarchyTypeMismatchException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class HierarchyTypeMismatchException extends HierarchyTypeMismatchException_base {
 }
-declare const IncompatiblePolicyException_base: S.ErrorClass<IncompatiblePolicyException, S.TaggedStruct<"IncompatiblePolicyException", {
+declare const IncompatiblePolicyException_base: S.Class<IncompatiblePolicyException, S.TaggedStruct<"IncompatiblePolicyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IncompatiblePolicyException extends IncompatiblePolicyException_base {
 }
-declare const InvalidAllowedPatternException_base: S.ErrorClass<InvalidAllowedPatternException, S.TaggedStruct<"InvalidAllowedPatternException", {
+declare const InvalidAllowedPatternException_base: S.Class<InvalidAllowedPatternException, S.TaggedStruct<"InvalidAllowedPatternException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAllowedPatternException extends InvalidAllowedPatternException_base {
 }
-declare const InvalidPolicyAttributeException_base: S.ErrorClass<InvalidPolicyAttributeException, S.TaggedStruct<"InvalidPolicyAttributeException", {
+declare const InvalidPolicyAttributeException_base: S.Class<InvalidPolicyAttributeException, S.TaggedStruct<"InvalidPolicyAttributeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPolicyAttributeException extends InvalidPolicyAttributeException_base {
 }
-declare const InvalidPolicyTypeException_base: S.ErrorClass<InvalidPolicyTypeException, S.TaggedStruct<"InvalidPolicyTypeException", {
+declare const InvalidPolicyTypeException_base: S.Class<InvalidPolicyTypeException, S.TaggedStruct<"InvalidPolicyTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPolicyTypeException extends InvalidPolicyTypeException_base {
 }
-declare const ParameterAlreadyExists_base: S.ErrorClass<ParameterAlreadyExists, S.TaggedStruct<"ParameterAlreadyExists", {
+declare const ParameterAlreadyExists_base: S.Class<ParameterAlreadyExists, S.TaggedStruct<"ParameterAlreadyExists", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5160,7 +5160,7 @@ declare const ParameterAlreadyExists_base: S.ErrorClass<ParameterAlreadyExists,
 });
 export declare class ParameterAlreadyExists extends ParameterAlreadyExists_base {
 }
-declare const ParameterLimitExceeded_base: S.ErrorClass<ParameterLimitExceeded, S.TaggedStruct<"ParameterLimitExceeded", {
+declare const ParameterLimitExceeded_base: S.Class<ParameterLimitExceeded, S.TaggedStruct<"ParameterLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5169,7 +5169,7 @@ declare const ParameterLimitExceeded_base: S.ErrorClass<ParameterLimitExceeded,
 });
 export declare class ParameterLimitExceeded extends ParameterLimitExceeded_base {
 }
-declare const ParameterMaxVersionLimitExceeded_base: S.ErrorClass<ParameterMaxVersionLimitExceeded, S.TaggedStruct<"ParameterMaxVersionLimitExceeded", {
+declare const ParameterMaxVersionLimitExceeded_base: S.Class<ParameterMaxVersionLimitExceeded, S.TaggedStruct<"ParameterMaxVersionLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5178,29 +5178,29 @@ declare const ParameterMaxVersionLimitExceeded_base: S.ErrorClass<ParameterMaxVe
 });
 export declare class ParameterMaxVersionLimitExceeded extends ParameterMaxVersionLimitExceeded_base {
 }
-declare const ParameterPatternMismatchException_base: S.ErrorClass<ParameterPatternMismatchException, S.TaggedStruct<"ParameterPatternMismatchException", {
+declare const ParameterPatternMismatchException_base: S.Class<ParameterPatternMismatchException, S.TaggedStruct<"ParameterPatternMismatchException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParameterPatternMismatchException extends ParameterPatternMismatchException_base {
 }
-declare const PoliciesLimitExceededException_base: S.ErrorClass<PoliciesLimitExceededException, S.TaggedStruct<"PoliciesLimitExceededException", {
+declare const PoliciesLimitExceededException_base: S.Class<PoliciesLimitExceededException, S.TaggedStruct<"PoliciesLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PoliciesLimitExceededException extends PoliciesLimitExceededException_base {
 }
-declare const UnsupportedParameterType_base: S.ErrorClass<UnsupportedParameterType, S.TaggedStruct<"UnsupportedParameterType", {
+declare const UnsupportedParameterType_base: S.Class<UnsupportedParameterType, S.TaggedStruct<"UnsupportedParameterType", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedParameterType extends UnsupportedParameterType_base {
 }
-declare const ResourcePolicyLimitExceededException_base: S.ErrorClass<ResourcePolicyLimitExceededException, S.TaggedStruct<"ResourcePolicyLimitExceededException", {
+declare const ResourcePolicyLimitExceededException_base: S.Class<ResourcePolicyLimitExceededException, S.TaggedStruct<"ResourcePolicyLimitExceededException", {
     readonly Limit: S.optional<S.Number>;
     readonly LimitType: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourcePolicyLimitExceededException extends ResourcePolicyLimitExceededException_base {
 }
-declare const AlreadyExistsException_base: S.ErrorClass<AlreadyExistsException, S.TaggedStruct<"AlreadyExistsException", {
+declare const AlreadyExistsException_base: S.Class<AlreadyExistsException, S.TaggedStruct<"AlreadyExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5209,35 +5209,35 @@ declare const AlreadyExistsException_base: S.ErrorClass<AlreadyExistsException,
 });
 export declare class AlreadyExistsException extends AlreadyExistsException_base {
 }
-declare const FeatureNotAvailableException_base: S.ErrorClass<FeatureNotAvailableException, S.TaggedStruct<"FeatureNotAvailableException", {
+declare const FeatureNotAvailableException_base: S.Class<FeatureNotAvailableException, S.TaggedStruct<"FeatureNotAvailableException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FeatureNotAvailableException extends FeatureNotAvailableException_base {
 }
-declare const AutomationStepNotFoundException_base: S.ErrorClass<AutomationStepNotFoundException, S.TaggedStruct<"AutomationStepNotFoundException", {
+declare const AutomationStepNotFoundException_base: S.Class<AutomationStepNotFoundException, S.TaggedStruct<"AutomationStepNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationStepNotFoundException extends AutomationStepNotFoundException_base {
 }
-declare const InvalidAutomationSignalException_base: S.ErrorClass<InvalidAutomationSignalException, S.TaggedStruct<"InvalidAutomationSignalException", {
+declare const InvalidAutomationSignalException_base: S.Class<InvalidAutomationSignalException, S.TaggedStruct<"InvalidAutomationSignalException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAutomationSignalException extends InvalidAutomationSignalException_base {
 }
-declare const InvalidNotificationConfig_base: S.ErrorClass<InvalidNotificationConfig, S.TaggedStruct<"InvalidNotificationConfig", {
+declare const InvalidNotificationConfig_base: S.Class<InvalidNotificationConfig, S.TaggedStruct<"InvalidNotificationConfig", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNotificationConfig extends InvalidNotificationConfig_base {
 }
-declare const InvalidOutputFolder_base: S.ErrorClass<InvalidOutputFolder, S.TaggedStruct<"InvalidOutputFolder", {}>, import("effect/Cause").YieldableError>;
+declare const InvalidOutputFolder_base: S.Class<InvalidOutputFolder, S.TaggedStruct<"InvalidOutputFolder", {}>, import("effect/Cause").YieldableError>;
 export declare class InvalidOutputFolder extends InvalidOutputFolder_base {
 }
-declare const InvalidRole_base: S.ErrorClass<InvalidRole, S.TaggedStruct<"InvalidRole", {
+declare const InvalidRole_base: S.Class<InvalidRole, S.TaggedStruct<"InvalidRole", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRole extends InvalidRole_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.String;
     readonly ResourceId: S.optional<S.String>;
     readonly ResourceType: S.optional<S.String>;
@@ -5246,47 +5246,47 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 }>, import("effect/Cause").YieldableError>;
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const InvalidAssociation_base: S.ErrorClass<InvalidAssociation, S.TaggedStruct<"InvalidAssociation", {
+declare const InvalidAssociation_base: S.Class<InvalidAssociation, S.TaggedStruct<"InvalidAssociation", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAssociation extends InvalidAssociation_base {
 }
-declare const AutomationDefinitionNotFoundException_base: S.ErrorClass<AutomationDefinitionNotFoundException, S.TaggedStruct<"AutomationDefinitionNotFoundException", {
+declare const AutomationDefinitionNotFoundException_base: S.Class<AutomationDefinitionNotFoundException, S.TaggedStruct<"AutomationDefinitionNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationDefinitionNotFoundException extends AutomationDefinitionNotFoundException_base {
 }
-declare const AutomationDefinitionVersionNotFoundException_base: S.ErrorClass<AutomationDefinitionVersionNotFoundException, S.TaggedStruct<"AutomationDefinitionVersionNotFoundException", {
+declare const AutomationDefinitionVersionNotFoundException_base: S.Class<AutomationDefinitionVersionNotFoundException, S.TaggedStruct<"AutomationDefinitionVersionNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationDefinitionVersionNotFoundException extends AutomationDefinitionVersionNotFoundException_base {
 }
-declare const AutomationExecutionLimitExceededException_base: S.ErrorClass<AutomationExecutionLimitExceededException, S.TaggedStruct<"AutomationExecutionLimitExceededException", {
+declare const AutomationExecutionLimitExceededException_base: S.Class<AutomationExecutionLimitExceededException, S.TaggedStruct<"AutomationExecutionLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationExecutionLimitExceededException extends AutomationExecutionLimitExceededException_base {
 }
-declare const InvalidAutomationExecutionParametersException_base: S.ErrorClass<InvalidAutomationExecutionParametersException, S.TaggedStruct<"InvalidAutomationExecutionParametersException", {
+declare const InvalidAutomationExecutionParametersException_base: S.Class<InvalidAutomationExecutionParametersException, S.TaggedStruct<"InvalidAutomationExecutionParametersException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAutomationExecutionParametersException extends InvalidAutomationExecutionParametersException_base {
 }
-declare const AutomationDefinitionNotApprovedException_base: S.ErrorClass<AutomationDefinitionNotApprovedException, S.TaggedStruct<"AutomationDefinitionNotApprovedException", {
+declare const AutomationDefinitionNotApprovedException_base: S.Class<AutomationDefinitionNotApprovedException, S.TaggedStruct<"AutomationDefinitionNotApprovedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AutomationDefinitionNotApprovedException extends AutomationDefinitionNotApprovedException_base {
 }
-declare const TargetNotConnected_base: S.ErrorClass<TargetNotConnected, S.TaggedStruct<"TargetNotConnected", {
+declare const TargetNotConnected_base: S.Class<TargetNotConnected, S.TaggedStruct<"TargetNotConnected", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetNotConnected extends TargetNotConnected_base {
 }
-declare const InvalidAutomationStatusUpdateException_base: S.ErrorClass<InvalidAutomationStatusUpdateException, S.TaggedStruct<"InvalidAutomationStatusUpdateException", {
+declare const InvalidAutomationStatusUpdateException_base: S.Class<InvalidAutomationStatusUpdateException, S.TaggedStruct<"InvalidAutomationStatusUpdateException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAutomationStatusUpdateException extends InvalidAutomationStatusUpdateException_base {
 }
-declare const AssociationVersionLimitExceeded_base: S.ErrorClass<AssociationVersionLimitExceeded, S.TaggedStruct<"AssociationVersionLimitExceeded", {
+declare const AssociationVersionLimitExceeded_base: S.Class<AssociationVersionLimitExceeded, S.TaggedStruct<"AssociationVersionLimitExceeded", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5295,15 +5295,15 @@ declare const AssociationVersionLimitExceeded_base: S.ErrorClass<AssociationVers
 });
 export declare class AssociationVersionLimitExceeded extends AssociationVersionLimitExceeded_base {
 }
-declare const InvalidUpdate_base: S.ErrorClass<InvalidUpdate, S.TaggedStruct<"InvalidUpdate", {
+declare const InvalidUpdate_base: S.Class<InvalidUpdate, S.TaggedStruct<"InvalidUpdate", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidUpdate extends InvalidUpdate_base {
 }
-declare const StatusUnchanged_base: S.ErrorClass<StatusUnchanged, S.TaggedStruct<"StatusUnchanged", {}>, import("effect/Cause").YieldableError>;
+declare const StatusUnchanged_base: S.Class<StatusUnchanged, S.TaggedStruct<"StatusUnchanged", {}>, import("effect/Cause").YieldableError>;
 export declare class StatusUnchanged extends StatusUnchanged_base {
 }
-declare const DocumentVersionLimitExceeded_base: S.ErrorClass<DocumentVersionLimitExceeded, S.TaggedStruct<"DocumentVersionLimitExceeded", {
+declare const DocumentVersionLimitExceeded_base: S.Class<DocumentVersionLimitExceeded, S.TaggedStruct<"DocumentVersionLimitExceeded", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -5312,22 +5312,22 @@ declare const DocumentVersionLimitExceeded_base: S.ErrorClass<DocumentVersionLim
 });
 export declare class DocumentVersionLimitExceeded extends DocumentVersionLimitExceeded_base {
 }
-declare const DuplicateDocumentContent_base: S.ErrorClass<DuplicateDocumentContent, S.TaggedStruct<"DuplicateDocumentContent", {
+declare const DuplicateDocumentContent_base: S.Class<DuplicateDocumentContent, S.TaggedStruct<"DuplicateDocumentContent", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicateDocumentContent extends DuplicateDocumentContent_base {
 }
-declare const DuplicateDocumentVersionName_base: S.ErrorClass<DuplicateDocumentVersionName, S.TaggedStruct<"DuplicateDocumentVersionName", {
+declare const DuplicateDocumentVersionName_base: S.Class<DuplicateDocumentVersionName, S.TaggedStruct<"DuplicateDocumentVersionName", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicateDocumentVersionName extends DuplicateDocumentVersionName_base {
 }
-declare const OpsMetadataKeyLimitExceededException_base: S.ErrorClass<OpsMetadataKeyLimitExceededException, S.TaggedStruct<"OpsMetadataKeyLimitExceededException", {
+declare const OpsMetadataKeyLimitExceededException_base: S.Class<OpsMetadataKeyLimitExceededException, S.TaggedStruct<"OpsMetadataKeyLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OpsMetadataKeyLimitExceededException extends OpsMetadataKeyLimitExceededException_base {
 }
-declare const ResourceDataSyncConflictException_base: S.ErrorClass<ResourceDataSyncConflictException, S.TaggedStruct<"ResourceDataSyncConflictException", {
+declare const ResourceDataSyncConflictException_base: S.Class<ResourceDataSyncConflictException, S.TaggedStruct<"ResourceDataSyncConflictException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceDataSyncConflictException extends ResourceDataSyncConflictException_base {