@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/controlcatalog.d.ts

@@ -275,7 +275,7 @@ export interface ListObjectivesResponse {
     NextToken?: string;
 }
 export declare const ListObjectivesResponse: S.Schema<ListObjectivesResponse>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -284,7 +284,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -297,7 +297,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -310,7 +310,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -319,7 +319,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/controltower.d.ts

@@ -588,7 +588,7 @@ export declare const UntagResourceInput: S.Schema<UntagResourceInput>;
 export interface UntagResourceOutput {
 }
 export declare const UntagResourceOutput: S.Schema<UntagResourceOutput>;
-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": {
@@ -597,7 +597,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -606,7 +606,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -619,7 +619,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -628,7 +628,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -637,7 +637,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.String;
     readonly serviceCode: S.optional<S.String>;
     readonly quotaCode: S.optional<S.String>;
@@ -653,7 +653,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/cost-and-usage-report-service.d.ts

@@ -126,7 +126,7 @@ export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
 export interface UntagResourceResponse {
 }
 export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
-declare const InternalErrorException_base: S.ErrorClass<InternalErrorException, S.TaggedStruct<"InternalErrorException", {
+declare const InternalErrorException_base: S.Class<InternalErrorException, S.TaggedStruct<"InternalErrorException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -135,22 +135,22 @@ declare const InternalErrorException_base: S.ErrorClass<InternalErrorException,
 });
 export declare class InternalErrorException extends InternalErrorException_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>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ValidationException extends ValidationException_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 DuplicateReportNameException_base: S.ErrorClass<DuplicateReportNameException, S.TaggedStruct<"DuplicateReportNameException", {
+declare const DuplicateReportNameException_base: S.Class<DuplicateReportNameException, S.TaggedStruct<"DuplicateReportNameException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicateReportNameException extends DuplicateReportNameException_base {
 }
-declare const ReportLimitReachedException_base: S.ErrorClass<ReportLimitReachedException, S.TaggedStruct<"ReportLimitReachedException", {
+declare const ReportLimitReachedException_base: S.Class<ReportLimitReachedException, S.TaggedStruct<"ReportLimitReachedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReportLimitReachedException extends ReportLimitReachedException_base {

package/lib/services/cost-explorer.d.ts

@@ -1712,12 +1712,12 @@ export interface UpdateCostCategoryDefinitionResponse {
     EffectiveStart?: string;
 }
 export declare const UpdateCostCategoryDefinitionResponse: S.Schema<UpdateCostCategoryDefinitionResponse>;
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const UnknownMonitorException_base: S.ErrorClass<UnknownMonitorException, S.TaggedStruct<"UnknownMonitorException", {
+declare const UnknownMonitorException_base: S.Class<UnknownMonitorException, S.TaggedStruct<"UnknownMonitorException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1726,7 +1726,7 @@ declare const UnknownMonitorException_base: S.ErrorClass<UnknownMonitorException
 });
 export declare class UnknownMonitorException extends UnknownMonitorException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1735,7 +1735,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const UnknownSubscriptionException_base: S.ErrorClass<UnknownSubscriptionException, S.TaggedStruct<"UnknownSubscriptionException", {
+declare const UnknownSubscriptionException_base: S.Class<UnknownSubscriptionException, S.TaggedStruct<"UnknownSubscriptionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1744,7 +1744,7 @@ declare const UnknownSubscriptionException_base: S.ErrorClass<UnknownSubscriptio
 });
 export declare class UnknownSubscriptionException extends UnknownSubscriptionException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1754,17 +1754,17 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
+declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const DataUnavailableException_base: S.ErrorClass<DataUnavailableException, S.TaggedStruct<"DataUnavailableException", {
+declare const DataUnavailableException_base: S.Class<DataUnavailableException, S.TaggedStruct<"DataUnavailableException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DataUnavailableException extends DataUnavailableException_base {
 }
-declare const AnalysisNotFoundException_base: S.ErrorClass<AnalysisNotFoundException, S.TaggedStruct<"AnalysisNotFoundException", {
+declare const AnalysisNotFoundException_base: S.Class<AnalysisNotFoundException, S.TaggedStruct<"AnalysisNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1773,27 +1773,27 @@ declare const AnalysisNotFoundException_base: S.ErrorClass<AnalysisNotFoundExcep
 });
 export declare class AnalysisNotFoundException extends AnalysisNotFoundException_base {
 }
-declare const BillExpirationException_base: S.ErrorClass<BillExpirationException, S.TaggedStruct<"BillExpirationException", {
+declare const BillExpirationException_base: S.Class<BillExpirationException, S.TaggedStruct<"BillExpirationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BillExpirationException extends BillExpirationException_base {
 }
-declare const BillingViewHealthStatusException_base: S.ErrorClass<BillingViewHealthStatusException, S.TaggedStruct<"BillingViewHealthStatusException", {
+declare const BillingViewHealthStatusException_base: S.Class<BillingViewHealthStatusException, S.TaggedStruct<"BillingViewHealthStatusException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BillingViewHealthStatusException extends BillingViewHealthStatusException_base {
 }
-declare const RequestChangedException_base: S.ErrorClass<RequestChangedException, S.TaggedStruct<"RequestChangedException", {
+declare const RequestChangedException_base: S.Class<RequestChangedException, S.TaggedStruct<"RequestChangedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RequestChangedException extends RequestChangedException_base {
 }
-declare const UnresolvableUsageUnitException_base: S.ErrorClass<UnresolvableUsageUnitException, S.TaggedStruct<"UnresolvableUsageUnitException", {
+declare const UnresolvableUsageUnitException_base: S.Class<UnresolvableUsageUnitException, S.TaggedStruct<"UnresolvableUsageUnitException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnresolvableUsageUnitException extends UnresolvableUsageUnitException_base {
 }
-declare const GenerationExistsException_base: S.ErrorClass<GenerationExistsException, S.TaggedStruct<"GenerationExistsException", {
+declare const GenerationExistsException_base: S.Class<GenerationExistsException, S.TaggedStruct<"GenerationExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1802,7 +1802,7 @@ declare const GenerationExistsException_base: S.ErrorClass<GenerationExistsExcep
 });
 export declare class GenerationExistsException extends GenerationExistsException_base {
 }
-declare const BackfillLimitExceededException_base: S.ErrorClass<BackfillLimitExceededException, S.TaggedStruct<"BackfillLimitExceededException", {
+declare const BackfillLimitExceededException_base: S.Class<BackfillLimitExceededException, S.TaggedStruct<"BackfillLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1811,7 +1811,7 @@ declare const BackfillLimitExceededException_base: S.ErrorClass<BackfillLimitExc
 });
 export declare class BackfillLimitExceededException extends BackfillLimitExceededException_base {
 }
-declare const TooManyTagsException_base: S.ErrorClass<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
+declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/cost-optimization-hub.d.ts

@@ -1059,7 +1059,7 @@ export interface UpdatePreferencesResponse {
     preferredCommitment?: PreferredCommitment;
 }
 export declare const UpdatePreferencesResponse: S.Schema<UpdatePreferencesResponse>;
-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": {
@@ -1068,7 +1068,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1077,7 +1077,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1086,7 +1086,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly message: S.String;
     readonly reason: S.optional<S.String>;
     readonly fields: S.optional<S.$Array<S.Schema<ValidationExceptionDetail>>>;
@@ -1097,7 +1097,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.String;
     readonly resourceId: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/customer-profiles.d.ts

@@ -2836,7 +2836,7 @@ export interface UpdateRecommenderResponse {
     RecommenderName: string;
 }
 export declare const UpdateRecommenderResponse: S.Schema<UpdateRecommenderResponse>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2845,7 +2845,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const BadRequestException_base: S.ErrorClass<BadRequestException, S.TaggedStruct<"BadRequestException", {
+declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2854,7 +2854,7 @@ declare const BadRequestException_base: S.ErrorClass<BadRequestException, S.Tagg
 });
 export declare class BadRequestException extends BadRequestException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2863,7 +2863,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2872,7 +2872,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/data-pipeline.d.ts

@@ -329,27 +329,27 @@ export interface ValidatePipelineDefinitionOutput {
     errored: boolean;
 }
 export declare const ValidatePipelineDefinitionOutput: S.Schema<ValidatePipelineDefinitionOutput>;
-declare const InternalServiceError_base: S.ErrorClass<InternalServiceError, S.TaggedStruct<"InternalServiceError", {
+declare const InternalServiceError_base: S.Class<InternalServiceError, S.TaggedStruct<"InternalServiceError", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServiceError extends InternalServiceError_base {
 }
-declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
+declare const InvalidRequestException_base: S.Class<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequestException extends InvalidRequestException_base {
 }
-declare const PipelineDeletedException_base: S.ErrorClass<PipelineDeletedException, S.TaggedStruct<"PipelineDeletedException", {
+declare const PipelineDeletedException_base: S.Class<PipelineDeletedException, S.TaggedStruct<"PipelineDeletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineDeletedException extends PipelineDeletedException_base {
 }
-declare const PipelineNotFoundException_base: S.ErrorClass<PipelineNotFoundException, S.TaggedStruct<"PipelineNotFoundException", {
+declare const PipelineNotFoundException_base: S.Class<PipelineNotFoundException, S.TaggedStruct<"PipelineNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineNotFoundException extends PipelineNotFoundException_base {
 }
-declare const TaskNotFoundException_base: S.ErrorClass<TaskNotFoundException, S.TaggedStruct<"TaskNotFoundException", {
+declare const TaskNotFoundException_base: S.Class<TaskNotFoundException, S.TaggedStruct<"TaskNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TaskNotFoundException extends TaskNotFoundException_base {

package/lib/services/database-migration-service.d.ts

@@ -3030,17 +3030,17 @@ export interface UpdateSubscriptionsToEventBridgeResponse {
     Result?: string;
 }
 export declare const UpdateSubscriptionsToEventBridgeResponse: S.Schema<UpdateSubscriptionsToEventBridgeResponse>;
-declare const InvalidResourceStateFault_base: S.ErrorClass<InvalidResourceStateFault, S.TaggedStruct<"InvalidResourceStateFault", {
+declare const InvalidResourceStateFault_base: S.Class<InvalidResourceStateFault, S.TaggedStruct<"InvalidResourceStateFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceStateFault extends InvalidResourceStateFault_base {
 }
-declare const ResourceNotFoundFault_base: S.ErrorClass<ResourceNotFoundFault, S.TaggedStruct<"ResourceNotFoundFault", {
+declare const ResourceNotFoundFault_base: S.Class<ResourceNotFoundFault, S.TaggedStruct<"ResourceNotFoundFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundFault extends ResourceNotFoundFault_base {
 }
-declare const AccessDeniedFault_base: S.ErrorClass<AccessDeniedFault, S.TaggedStruct<"AccessDeniedFault", {
+declare const AccessDeniedFault_base: S.Class<AccessDeniedFault, S.TaggedStruct<"AccessDeniedFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -3049,17 +3049,17 @@ declare const AccessDeniedFault_base: S.ErrorClass<AccessDeniedFault, S.TaggedSt
 });
 export declare class AccessDeniedFault extends AccessDeniedFault_base {
 }
-declare const FailedDependencyFault_base: S.ErrorClass<FailedDependencyFault, S.TaggedStruct<"FailedDependencyFault", {
+declare const FailedDependencyFault_base: S.Class<FailedDependencyFault, S.TaggedStruct<"FailedDependencyFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FailedDependencyFault extends FailedDependencyFault_base {
 }
-declare const InvalidOperationFault_base: S.ErrorClass<InvalidOperationFault, S.TaggedStruct<"InvalidOperationFault", {
+declare const InvalidOperationFault_base: S.Class<InvalidOperationFault, S.TaggedStruct<"InvalidOperationFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOperationFault extends InvalidOperationFault_base {
 }
-declare const ResourceAlreadyExistsFault_base: S.ErrorClass<ResourceAlreadyExistsFault, S.TaggedStruct<"ResourceAlreadyExistsFault", {
+declare const ResourceAlreadyExistsFault_base: S.Class<ResourceAlreadyExistsFault, S.TaggedStruct<"ResourceAlreadyExistsFault", {
     readonly message: S.optional<S.String>;
     readonly resourceArn: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3069,17 +3069,17 @@ declare const ResourceAlreadyExistsFault_base: S.ErrorClass<ResourceAlreadyExist
 });
 export declare class ResourceAlreadyExistsFault extends ResourceAlreadyExistsFault_base {
 }
-declare const ResourceQuotaExceededFault_base: S.ErrorClass<ResourceQuotaExceededFault, S.TaggedStruct<"ResourceQuotaExceededFault", {
+declare const ResourceQuotaExceededFault_base: S.Class<ResourceQuotaExceededFault, S.TaggedStruct<"ResourceQuotaExceededFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceQuotaExceededFault extends ResourceQuotaExceededFault_base {
 }
-declare const KMSKeyNotAccessibleFault_base: S.ErrorClass<KMSKeyNotAccessibleFault, S.TaggedStruct<"KMSKeyNotAccessibleFault", {
+declare const KMSKeyNotAccessibleFault_base: S.Class<KMSKeyNotAccessibleFault, S.TaggedStruct<"KMSKeyNotAccessibleFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSKeyNotAccessibleFault extends KMSKeyNotAccessibleFault_base {
 }
-declare const S3AccessDeniedFault_base: S.ErrorClass<S3AccessDeniedFault, S.TaggedStruct<"S3AccessDeniedFault", {
+declare const S3AccessDeniedFault_base: S.Class<S3AccessDeniedFault, S.TaggedStruct<"S3AccessDeniedFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -3088,7 +3088,7 @@ declare const S3AccessDeniedFault_base: S.ErrorClass<S3AccessDeniedFault, S.Tagg
 });
 export declare class S3AccessDeniedFault extends S3AccessDeniedFault_base {
 }
-declare const KMSAccessDeniedFault_base: S.ErrorClass<KMSAccessDeniedFault, S.TaggedStruct<"KMSAccessDeniedFault", {
+declare const KMSAccessDeniedFault_base: S.Class<KMSAccessDeniedFault, S.TaggedStruct<"KMSAccessDeniedFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -3097,62 +3097,62 @@ declare const KMSAccessDeniedFault_base: S.ErrorClass<KMSAccessDeniedFault, S.Ta
 });
 export declare class KMSAccessDeniedFault extends KMSAccessDeniedFault_base {
 }
-declare const KMSDisabledFault_base: S.ErrorClass<KMSDisabledFault, S.TaggedStruct<"KMSDisabledFault", {
+declare const KMSDisabledFault_base: S.Class<KMSDisabledFault, S.TaggedStruct<"KMSDisabledFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSDisabledFault extends KMSDisabledFault_base {
 }
-declare const KMSInvalidStateFault_base: S.ErrorClass<KMSInvalidStateFault, S.TaggedStruct<"KMSInvalidStateFault", {
+declare const KMSInvalidStateFault_base: S.Class<KMSInvalidStateFault, S.TaggedStruct<"KMSInvalidStateFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSInvalidStateFault extends KMSInvalidStateFault_base {
 }
-declare const KMSNotFoundFault_base: S.ErrorClass<KMSNotFoundFault, S.TaggedStruct<"KMSNotFoundFault", {
+declare const KMSNotFoundFault_base: S.Class<KMSNotFoundFault, S.TaggedStruct<"KMSNotFoundFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSNotFoundFault extends KMSNotFoundFault_base {
 }
-declare const KMSThrottlingFault_base: S.ErrorClass<KMSThrottlingFault, S.TaggedStruct<"KMSThrottlingFault", {
+declare const KMSThrottlingFault_base: S.Class<KMSThrottlingFault, S.TaggedStruct<"KMSThrottlingFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSThrottlingFault extends KMSThrottlingFault_base {
 }
-declare const SNSInvalidTopicFault_base: S.ErrorClass<SNSInvalidTopicFault, S.TaggedStruct<"SNSInvalidTopicFault", {
+declare const SNSInvalidTopicFault_base: S.Class<SNSInvalidTopicFault, S.TaggedStruct<"SNSInvalidTopicFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SNSInvalidTopicFault extends SNSInvalidTopicFault_base {
 }
-declare const SNSNoAuthorizationFault_base: S.ErrorClass<SNSNoAuthorizationFault, S.TaggedStruct<"SNSNoAuthorizationFault", {
+declare const SNSNoAuthorizationFault_base: S.Class<SNSNoAuthorizationFault, S.TaggedStruct<"SNSNoAuthorizationFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SNSNoAuthorizationFault extends SNSNoAuthorizationFault_base {
 }
-declare const S3ResourceNotFoundFault_base: S.ErrorClass<S3ResourceNotFoundFault, S.TaggedStruct<"S3ResourceNotFoundFault", {
+declare const S3ResourceNotFoundFault_base: S.Class<S3ResourceNotFoundFault, S.TaggedStruct<"S3ResourceNotFoundFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class S3ResourceNotFoundFault extends S3ResourceNotFoundFault_base {
 }
-declare const InvalidSubnet_base: S.ErrorClass<InvalidSubnet, S.TaggedStruct<"InvalidSubnet", {
+declare const InvalidSubnet_base: S.Class<InvalidSubnet, S.TaggedStruct<"InvalidSubnet", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSubnet extends InvalidSubnet_base {
 }
-declare const ReplicationSubnetGroupDoesNotCoverEnoughAZs_base: S.ErrorClass<ReplicationSubnetGroupDoesNotCoverEnoughAZs, S.TaggedStruct<"ReplicationSubnetGroupDoesNotCoverEnoughAZs", {
+declare const ReplicationSubnetGroupDoesNotCoverEnoughAZs_base: S.Class<ReplicationSubnetGroupDoesNotCoverEnoughAZs, S.TaggedStruct<"ReplicationSubnetGroupDoesNotCoverEnoughAZs", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReplicationSubnetGroupDoesNotCoverEnoughAZs extends ReplicationSubnetGroupDoesNotCoverEnoughAZs_base {
 }
-declare const InsufficientResourceCapacityFault_base: S.ErrorClass<InsufficientResourceCapacityFault, S.TaggedStruct<"InsufficientResourceCapacityFault", {
+declare const InsufficientResourceCapacityFault_base: S.Class<InsufficientResourceCapacityFault, S.TaggedStruct<"InsufficientResourceCapacityFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InsufficientResourceCapacityFault extends InsufficientResourceCapacityFault_base {
 }
-declare const StorageQuotaExceededFault_base: S.ErrorClass<StorageQuotaExceededFault, S.TaggedStruct<"StorageQuotaExceededFault", {
+declare const StorageQuotaExceededFault_base: S.Class<StorageQuotaExceededFault, S.TaggedStruct<"StorageQuotaExceededFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StorageQuotaExceededFault extends StorageQuotaExceededFault_base {
 }
-declare const CollectorNotFoundFault_base: S.ErrorClass<CollectorNotFoundFault, S.TaggedStruct<"CollectorNotFoundFault", {
+declare const CollectorNotFoundFault_base: S.Class<CollectorNotFoundFault, S.TaggedStruct<"CollectorNotFoundFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -3161,17 +3161,17 @@ declare const CollectorNotFoundFault_base: S.ErrorClass<CollectorNotFoundFault,
 });
 export declare class CollectorNotFoundFault extends CollectorNotFoundFault_base {
 }
-declare const InvalidCertificateFault_base: S.ErrorClass<InvalidCertificateFault, S.TaggedStruct<"InvalidCertificateFault", {
+declare const InvalidCertificateFault_base: S.Class<InvalidCertificateFault, S.TaggedStruct<"InvalidCertificateFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCertificateFault extends InvalidCertificateFault_base {
 }
-declare const UpgradeDependencyFailureFault_base: S.ErrorClass<UpgradeDependencyFailureFault, S.TaggedStruct<"UpgradeDependencyFailureFault", {
+declare const UpgradeDependencyFailureFault_base: S.Class<UpgradeDependencyFailureFault, S.TaggedStruct<"UpgradeDependencyFailureFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UpgradeDependencyFailureFault extends UpgradeDependencyFailureFault_base {
 }
-declare const SubnetAlreadyInUse_base: S.ErrorClass<SubnetAlreadyInUse, S.TaggedStruct<"SubnetAlreadyInUse", {
+declare const SubnetAlreadyInUse_base: S.Class<SubnetAlreadyInUse, S.TaggedStruct<"SubnetAlreadyInUse", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -3180,7 +3180,7 @@ declare const SubnetAlreadyInUse_base: S.ErrorClass<SubnetAlreadyInUse, S.Tagged
 });
 export declare class SubnetAlreadyInUse extends SubnetAlreadyInUse_base {
 }
-declare const KMSFault_base: S.ErrorClass<KMSFault, S.TaggedStruct<"KMSFault", {
+declare const KMSFault_base: S.Class<KMSFault, S.TaggedStruct<"KMSFault", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSFault extends KMSFault_base {

package/lib/services/databrew.d.ts

@@ -1168,7 +1168,7 @@ export interface UpdateScheduleResponse {
     Name: string;
 }
 export declare const UpdateScheduleResponse: S.Schema<UpdateScheduleResponse>;
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1177,7 +1177,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1186,7 +1186,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1195,7 +1195,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1204,7 +1204,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1213,7 +1213,7 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {