@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/sfn.d.ts

@@ -1048,7 +1048,7 @@ export interface ValidateStateMachineDefinitionOutput {
     truncated?: boolean;
 }
 export declare const ValidateStateMachineDefinitionOutput: S.Schema<ValidateStateMachineDefinitionOutput>;
-declare const ActivityAlreadyExists_base: S.ErrorClass<ActivityAlreadyExists, S.TaggedStruct<"ActivityAlreadyExists", {
+declare const ActivityAlreadyExists_base: S.Class<ActivityAlreadyExists, S.TaggedStruct<"ActivityAlreadyExists", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1057,7 +1057,7 @@ declare const ActivityAlreadyExists_base: S.ErrorClass<ActivityAlreadyExists, S.
 });
 export declare class ActivityAlreadyExists extends ActivityAlreadyExists_base {
 }
-declare const ActivityLimitExceeded_base: S.ErrorClass<ActivityLimitExceeded, S.TaggedStruct<"ActivityLimitExceeded", {
+declare const ActivityLimitExceeded_base: S.Class<ActivityLimitExceeded, S.TaggedStruct<"ActivityLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1066,17 +1066,17 @@ declare const ActivityLimitExceeded_base: S.ErrorClass<ActivityLimitExceeded, S.
 });
 export declare class ActivityLimitExceeded extends ActivityLimitExceeded_base {
 }
-declare const InvalidEncryptionConfiguration_base: S.ErrorClass<InvalidEncryptionConfiguration, S.TaggedStruct<"InvalidEncryptionConfiguration", {
+declare const InvalidEncryptionConfiguration_base: S.Class<InvalidEncryptionConfiguration, S.TaggedStruct<"InvalidEncryptionConfiguration", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidEncryptionConfiguration extends InvalidEncryptionConfiguration_base {
 }
-declare const InvalidName_base: S.ErrorClass<InvalidName, S.TaggedStruct<"InvalidName", {
+declare const InvalidName_base: S.Class<InvalidName, S.TaggedStruct<"InvalidName", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidName extends InvalidName_base {
 }
-declare const KmsAccessDeniedException_base: S.ErrorClass<KmsAccessDeniedException, S.TaggedStruct<"KmsAccessDeniedException", {
+declare const KmsAccessDeniedException_base: S.Class<KmsAccessDeniedException, S.TaggedStruct<"KmsAccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1085,12 +1085,12 @@ declare const KmsAccessDeniedException_base: S.ErrorClass<KmsAccessDeniedExcepti
 });
 export declare class KmsAccessDeniedException extends KmsAccessDeniedException_base {
 }
-declare const KmsThrottlingException_base: S.ErrorClass<KmsThrottlingException, S.TaggedStruct<"KmsThrottlingException", {
+declare const KmsThrottlingException_base: S.Class<KmsThrottlingException, S.TaggedStruct<"KmsThrottlingException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KmsThrottlingException extends KmsThrottlingException_base {
 }
-declare const TooManyTags_base: S.ErrorClass<TooManyTags, S.TaggedStruct<"TooManyTags", {
+declare const TooManyTags_base: S.Class<TooManyTags, S.TaggedStruct<"TooManyTags", {
     readonly message: S.optional<S.String>;
     readonly resourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1100,7 +1100,7 @@ declare const TooManyTags_base: S.ErrorClass<TooManyTags, S.TaggedStruct<"TooMan
 });
 export declare class TooManyTags extends TooManyTags_base {
 }
-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": {
@@ -1109,27 +1109,27 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InvalidArn_base: S.ErrorClass<InvalidArn, S.TaggedStruct<"InvalidArn", {
+declare const InvalidArn_base: S.Class<InvalidArn, S.TaggedStruct<"InvalidArn", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidArn extends InvalidArn_base {
 }
-declare const InvalidDefinition_base: S.ErrorClass<InvalidDefinition, S.TaggedStruct<"InvalidDefinition", {
+declare const InvalidDefinition_base: S.Class<InvalidDefinition, S.TaggedStruct<"InvalidDefinition", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDefinition extends InvalidDefinition_base {
 }
-declare const InvalidLoggingConfiguration_base: S.ErrorClass<InvalidLoggingConfiguration, S.TaggedStruct<"InvalidLoggingConfiguration", {
+declare const InvalidLoggingConfiguration_base: S.Class<InvalidLoggingConfiguration, S.TaggedStruct<"InvalidLoggingConfiguration", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLoggingConfiguration extends InvalidLoggingConfiguration_base {
 }
-declare const InvalidTracingConfiguration_base: S.ErrorClass<InvalidTracingConfiguration, S.TaggedStruct<"InvalidTracingConfiguration", {
+declare const InvalidTracingConfiguration_base: S.Class<InvalidTracingConfiguration, S.TaggedStruct<"InvalidTracingConfiguration", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTracingConfiguration extends InvalidTracingConfiguration_base {
 }
-declare const StateMachineAlreadyExists_base: S.ErrorClass<StateMachineAlreadyExists, S.TaggedStruct<"StateMachineAlreadyExists", {
+declare const StateMachineAlreadyExists_base: S.Class<StateMachineAlreadyExists, S.TaggedStruct<"StateMachineAlreadyExists", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1138,12 +1138,12 @@ declare const StateMachineAlreadyExists_base: S.ErrorClass<StateMachineAlreadyEx
 });
 export declare class StateMachineAlreadyExists extends StateMachineAlreadyExists_base {
 }
-declare const StateMachineDeleting_base: S.ErrorClass<StateMachineDeleting, S.TaggedStruct<"StateMachineDeleting", {
+declare const StateMachineDeleting_base: S.Class<StateMachineDeleting, S.TaggedStruct<"StateMachineDeleting", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StateMachineDeleting extends StateMachineDeleting_base {
 }
-declare const StateMachineLimitExceeded_base: S.ErrorClass<StateMachineLimitExceeded, S.TaggedStruct<"StateMachineLimitExceeded", {
+declare const StateMachineLimitExceeded_base: S.Class<StateMachineLimitExceeded, S.TaggedStruct<"StateMachineLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1152,12 +1152,12 @@ declare const StateMachineLimitExceeded_base: S.ErrorClass<StateMachineLimitExce
 });
 export declare class StateMachineLimitExceeded extends StateMachineLimitExceeded_base {
 }
-declare const StateMachineTypeNotSupported_base: S.ErrorClass<StateMachineTypeNotSupported, S.TaggedStruct<"StateMachineTypeNotSupported", {
+declare const StateMachineTypeNotSupported_base: S.Class<StateMachineTypeNotSupported, S.TaggedStruct<"StateMachineTypeNotSupported", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StateMachineTypeNotSupported extends StateMachineTypeNotSupported_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 reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1167,7 +1167,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ResourceNotFound_base: S.ErrorClass<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
+declare const ResourceNotFound_base: S.Class<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
     readonly message: S.optional<S.String>;
     readonly resourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1177,7 +1177,7 @@ declare const ResourceNotFound_base: S.ErrorClass<ResourceNotFound, S.TaggedStru
 });
 export declare class ResourceNotFound extends ResourceNotFound_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": {
@@ -1186,28 +1186,28 @@ declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExcee
 });
 export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
 }
-declare const ActivityDoesNotExist_base: S.ErrorClass<ActivityDoesNotExist, S.TaggedStruct<"ActivityDoesNotExist", {
+declare const ActivityDoesNotExist_base: S.Class<ActivityDoesNotExist, S.TaggedStruct<"ActivityDoesNotExist", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActivityDoesNotExist extends ActivityDoesNotExist_base {
 }
-declare const ExecutionDoesNotExist_base: S.ErrorClass<ExecutionDoesNotExist, S.TaggedStruct<"ExecutionDoesNotExist", {
+declare const ExecutionDoesNotExist_base: S.Class<ExecutionDoesNotExist, S.TaggedStruct<"ExecutionDoesNotExist", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExecutionDoesNotExist extends ExecutionDoesNotExist_base {
 }
-declare const KmsInvalidStateException_base: S.ErrorClass<KmsInvalidStateException, S.TaggedStruct<"KmsInvalidStateException", {
+declare const KmsInvalidStateException_base: S.Class<KmsInvalidStateException, S.TaggedStruct<"KmsInvalidStateException", {
     readonly kmsKeyState: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KmsInvalidStateException extends KmsInvalidStateException_base {
 }
-declare const StateMachineDoesNotExist_base: S.ErrorClass<StateMachineDoesNotExist, S.TaggedStruct<"StateMachineDoesNotExist", {
+declare const StateMachineDoesNotExist_base: S.Class<StateMachineDoesNotExist, S.TaggedStruct<"StateMachineDoesNotExist", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StateMachineDoesNotExist extends StateMachineDoesNotExist_base {
 }
-declare const ActivityWorkerLimitExceeded_base: S.ErrorClass<ActivityWorkerLimitExceeded, S.TaggedStruct<"ActivityWorkerLimitExceeded", {
+declare const ActivityWorkerLimitExceeded_base: S.Class<ActivityWorkerLimitExceeded, S.TaggedStruct<"ActivityWorkerLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1216,12 +1216,12 @@ declare const ActivityWorkerLimitExceeded_base: S.ErrorClass<ActivityWorkerLimit
 });
 export declare class ActivityWorkerLimitExceeded extends ActivityWorkerLimitExceeded_base {
 }
-declare const InvalidToken_base: S.ErrorClass<InvalidToken, S.TaggedStruct<"InvalidToken", {
+declare const InvalidToken_base: S.Class<InvalidToken, S.TaggedStruct<"InvalidToken", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidToken extends InvalidToken_base {
 }
-declare const ExecutionLimitExceeded_base: S.ErrorClass<ExecutionLimitExceeded, S.TaggedStruct<"ExecutionLimitExceeded", {
+declare const ExecutionLimitExceeded_base: S.Class<ExecutionLimitExceeded, S.TaggedStruct<"ExecutionLimitExceeded", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1230,27 +1230,27 @@ declare const ExecutionLimitExceeded_base: S.ErrorClass<ExecutionLimitExceeded,
 });
 export declare class ExecutionLimitExceeded extends ExecutionLimitExceeded_base {
 }
-declare const ExecutionNotRedrivable_base: S.ErrorClass<ExecutionNotRedrivable, S.TaggedStruct<"ExecutionNotRedrivable", {
+declare const ExecutionNotRedrivable_base: S.Class<ExecutionNotRedrivable, S.TaggedStruct<"ExecutionNotRedrivable", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExecutionNotRedrivable extends ExecutionNotRedrivable_base {
 }
-declare const TaskDoesNotExist_base: S.ErrorClass<TaskDoesNotExist, S.TaggedStruct<"TaskDoesNotExist", {
+declare const TaskDoesNotExist_base: S.Class<TaskDoesNotExist, S.TaggedStruct<"TaskDoesNotExist", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TaskDoesNotExist extends TaskDoesNotExist_base {
 }
-declare const TaskTimedOut_base: S.ErrorClass<TaskTimedOut, S.TaggedStruct<"TaskTimedOut", {
+declare const TaskTimedOut_base: S.Class<TaskTimedOut, S.TaggedStruct<"TaskTimedOut", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TaskTimedOut extends TaskTimedOut_base {
 }
-declare const InvalidOutput_base: S.ErrorClass<InvalidOutput, S.TaggedStruct<"InvalidOutput", {
+declare const InvalidOutput_base: S.Class<InvalidOutput, S.TaggedStruct<"InvalidOutput", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOutput extends InvalidOutput_base {
 }
-declare const ExecutionAlreadyExists_base: S.ErrorClass<ExecutionAlreadyExists, S.TaggedStruct<"ExecutionAlreadyExists", {
+declare const ExecutionAlreadyExists_base: S.Class<ExecutionAlreadyExists, S.TaggedStruct<"ExecutionAlreadyExists", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1259,12 +1259,12 @@ declare const ExecutionAlreadyExists_base: S.ErrorClass<ExecutionAlreadyExists,
 });
 export declare class ExecutionAlreadyExists extends ExecutionAlreadyExists_base {
 }
-declare const InvalidExecutionInput_base: S.ErrorClass<InvalidExecutionInput, S.TaggedStruct<"InvalidExecutionInput", {
+declare const InvalidExecutionInput_base: S.Class<InvalidExecutionInput, S.TaggedStruct<"InvalidExecutionInput", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExecutionInput extends InvalidExecutionInput_base {
 }
-declare const MissingRequiredParameter_base: S.ErrorClass<MissingRequiredParameter, S.TaggedStruct<"MissingRequiredParameter", {
+declare const MissingRequiredParameter_base: S.Class<MissingRequiredParameter, S.TaggedStruct<"MissingRequiredParameter", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MissingRequiredParameter extends MissingRequiredParameter_base {

package/lib/services/shield.d.ts

@@ -576,7 +576,7 @@ export declare const UpdateSubscriptionRequest: S.Schema<UpdateSubscriptionReque
 export interface UpdateSubscriptionResponse {
 }
 export declare const UpdateSubscriptionResponse: S.Schema<UpdateSubscriptionResponse>;
-declare const AccessDeniedForDependencyException_base: S.ErrorClass<AccessDeniedForDependencyException, S.TaggedStruct<"AccessDeniedForDependencyException", {
+declare const AccessDeniedForDependencyException_base: S.Class<AccessDeniedForDependencyException, S.TaggedStruct<"AccessDeniedForDependencyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -585,7 +585,7 @@ declare const AccessDeniedForDependencyException_base: S.ErrorClass<AccessDenied
 });
 export declare class AccessDeniedForDependencyException extends AccessDeniedForDependencyException_base {
 }
-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": {
@@ -594,47 +594,47 @@ declare const InternalErrorException_base: S.ErrorClass<InternalErrorException,
 });
 export declare class InternalErrorException extends InternalErrorException_base {
 }
-declare const InvalidOperationException_base: S.ErrorClass<InvalidOperationException, S.TaggedStruct<"InvalidOperationException", {
+declare const InvalidOperationException_base: S.Class<InvalidOperationException, S.TaggedStruct<"InvalidOperationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOperationException extends InvalidOperationException_base {
 }
-declare const InvalidParameterException_base: S.ErrorClass<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
+declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
     readonly message: S.optional<S.String>;
     readonly reason: S.optional<S.String>;
     readonly fields: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterException extends InvalidParameterException_base {
 }
-declare const LimitsExceededException_base: S.ErrorClass<LimitsExceededException, S.TaggedStruct<"LimitsExceededException", {
+declare const LimitsExceededException_base: S.Class<LimitsExceededException, S.TaggedStruct<"LimitsExceededException", {
     readonly message: S.optional<S.String>;
     readonly Type: S.optional<S.String>;
     readonly Limit: S.optional<S.Number>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitsExceededException extends LimitsExceededException_base {
 }
-declare const NoAssociatedRoleException_base: S.ErrorClass<NoAssociatedRoleException, S.TaggedStruct<"NoAssociatedRoleException", {
+declare const NoAssociatedRoleException_base: S.Class<NoAssociatedRoleException, S.TaggedStruct<"NoAssociatedRoleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoAssociatedRoleException extends NoAssociatedRoleException_base {
 }
-declare const OptimisticLockException_base: S.ErrorClass<OptimisticLockException, S.TaggedStruct<"OptimisticLockException", {
+declare const OptimisticLockException_base: S.Class<OptimisticLockException, S.TaggedStruct<"OptimisticLockException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OptimisticLockException extends OptimisticLockException_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 resourceType: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const InvalidResourceException_base: S.ErrorClass<InvalidResourceException, S.TaggedStruct<"InvalidResourceException", {
+declare const InvalidResourceException_base: S.Class<InvalidResourceException, S.TaggedStruct<"InvalidResourceException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceException extends InvalidResourceException_base {
 }
-declare const ResourceAlreadyExistsException_base: S.ErrorClass<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
+declare const ResourceAlreadyExistsException_base: S.Class<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
     readonly message: S.optional<S.String>;
     readonly resourceType: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -644,12 +644,12 @@ declare const ResourceAlreadyExistsException_base: S.ErrorClass<ResourceAlreadyE
 });
 export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
 }
-declare const LockedSubscriptionException_base: S.ErrorClass<LockedSubscriptionException, S.TaggedStruct<"LockedSubscriptionException", {
+declare const LockedSubscriptionException_base: S.Class<LockedSubscriptionException, S.TaggedStruct<"LockedSubscriptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LockedSubscriptionException extends LockedSubscriptionException_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": {
@@ -658,7 +658,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InvalidPaginationTokenException_base: S.ErrorClass<InvalidPaginationTokenException, S.TaggedStruct<"InvalidPaginationTokenException", {
+declare const InvalidPaginationTokenException_base: S.Class<InvalidPaginationTokenException, S.TaggedStruct<"InvalidPaginationTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPaginationTokenException extends InvalidPaginationTokenException_base {

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

@@ -24,7 +24,7 @@ export interface GetRevocationStatusResponse {
     revokedEntities?: string[];
 }
 export declare const GetRevocationStatusResponse: S.Schema<GetRevocationStatusResponse>;
-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>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -34,7 +34,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
+declare const InternalServiceErrorException_base: S.Class<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -44,7 +44,7 @@ declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceEr
 });
 export declare class InternalServiceErrorException extends InternalServiceErrorException_base {
 }
-declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
+declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -54,7 +54,7 @@ declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsExcepti
 });
 export declare class TooManyRequestsException extends TooManyRequestsException_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 code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/signer.d.ts

@@ -476,7 +476,7 @@ export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
 export interface UntagResourceResponse {
 }
 export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
-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>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -486,7 +486,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.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -496,7 +496,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
+declare const InternalServiceErrorException_base: S.Class<InternalServiceErrorException, S.TaggedStruct<"InternalServiceErrorException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -506,7 +506,7 @@ declare const InternalServiceErrorException_base: S.ErrorClass<InternalServiceEr
 });
 export declare class InternalServiceErrorException extends InternalServiceErrorException_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 code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -516,7 +516,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ServiceLimitExceededException_base: S.ErrorClass<ServiceLimitExceededException, S.TaggedStruct<"ServiceLimitExceededException", {
+declare const ServiceLimitExceededException_base: S.Class<ServiceLimitExceededException, S.TaggedStruct<"ServiceLimitExceededException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -526,7 +526,7 @@ declare const ServiceLimitExceededException_base: S.ErrorClass<ServiceLimitExcee
 });
 export declare class ServiceLimitExceededException extends ServiceLimitExceededException_base {
 }
-declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
+declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -536,7 +536,7 @@ declare const TooManyRequestsException_base: S.ErrorClass<TooManyRequestsExcepti
 });
 export declare class TooManyRequestsException extends TooManyRequestsException_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 code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -546,7 +546,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -556,7 +556,7 @@ declare const BadRequestException_base: S.ErrorClass<BadRequestException, S.Tagg
 });
 export declare class BadRequestException extends BadRequestException_base {
 }
-declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedStruct<"NotFoundException", {
+declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
     readonly message: S.optional<S.String>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -566,7 +566,7 @@ declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedSt
 });
 export declare class NotFoundException extends NotFoundException_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>;
     readonly code: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/signin.d.ts

@@ -47,7 +47,7 @@ export interface CreateOAuth2TokenResponse {
 export declare const CreateOAuth2TokenResponse: S.Schema<CreateOAuth2TokenResponse>;
 export type OAuth2ErrorCode = "TOKEN_EXPIRED" | "USER_CREDENTIALS_CHANGED" | "INSUFFICIENT_PERMISSIONS" | "AUTHCODE_EXPIRED" | "server_error" | "INVALID_REQUEST" | (string & {});
 export declare const OAuth2ErrorCode: S.String;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly error: S.String;
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -57,7 +57,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 error: S.String;
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -67,7 +67,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const TooManyRequestsError_base: S.ErrorClass<TooManyRequestsError, S.TaggedStruct<"TooManyRequestsError", {
+declare const TooManyRequestsError_base: S.Class<TooManyRequestsError, S.TaggedStruct<"TooManyRequestsError", {
     readonly error: S.String;
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -77,7 +77,7 @@ declare const TooManyRequestsError_base: S.ErrorClass<TooManyRequestsError, S.Ta
 });
 export declare class TooManyRequestsError extends TooManyRequestsError_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly error: S.String;
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/lib/services/simpledbv2.d.ts

@@ -82,7 +82,7 @@ export interface StartDomainExportResponse {
     requestedAt: Date;
 }
 export declare const StartDomainExportResponse: S.Schema<StartDomainExportResponse>;
-declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
+declare const InvalidParameterValueException_base: S.Class<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -91,7 +91,7 @@ declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameter
 });
 export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
 }
-declare const NoSuchExportException_base: S.ErrorClass<NoSuchExportException, S.TaggedStruct<"NoSuchExportException", {
+declare const NoSuchExportException_base: S.Class<NoSuchExportException, S.TaggedStruct<"NoSuchExportException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -100,7 +100,7 @@ declare const NoSuchExportException_base: S.ErrorClass<NoSuchExportException, S.
 });
 export declare class NoSuchExportException extends NoSuchExportException_base {
 }
-declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
+declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -109,7 +109,7 @@ declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenExcep
 });
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const NoSuchDomainException_base: S.ErrorClass<NoSuchDomainException, S.TaggedStruct<"NoSuchDomainException", {
+declare const NoSuchDomainException_base: S.Class<NoSuchDomainException, S.TaggedStruct<"NoSuchDomainException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -118,7 +118,7 @@ declare const NoSuchDomainException_base: S.ErrorClass<NoSuchDomainException, S.
 });
 export declare class NoSuchDomainException extends NoSuchDomainException_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": {
@@ -127,7 +127,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InvalidParameterCombinationException_base: S.ErrorClass<InvalidParameterCombinationException, S.TaggedStruct<"InvalidParameterCombinationException", {
+declare const InvalidParameterCombinationException_base: S.Class<InvalidParameterCombinationException, S.TaggedStruct<"InvalidParameterCombinationException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -136,7 +136,7 @@ declare const InvalidParameterCombinationException_base: S.ErrorClass<InvalidPar
 });
 export declare class InvalidParameterCombinationException extends InvalidParameterCombinationException_base {
 }
-declare const NumberExportsLimitExceeded_base: S.ErrorClass<NumberExportsLimitExceeded, S.TaggedStruct<"NumberExportsLimitExceeded", {
+declare const NumberExportsLimitExceeded_base: S.Class<NumberExportsLimitExceeded, S.TaggedStruct<"NumberExportsLimitExceeded", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/simspaceweaver.d.ts

@@ -295,7 +295,7 @@ export declare const StopClockInput: S.Schema<StopClockInput>;
 export interface StopClockOutput {
 }
 export declare const StopClockOutput: S.Schema<StopClockOutput>;
-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": {
@@ -304,7 +304,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": {
@@ -313,7 +313,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -322,7 +322,7 @@ declare const TooManyTagsException_base: S.ErrorClass<TooManyTagsException, S.Ta
 });
 export declare class TooManyTagsException extends TooManyTagsException_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": {
@@ -331,7 +331,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.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -340,7 +340,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.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -349,7 +349,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_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": {