@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/fsx.d.ts

@@ -3520,68 +3520,68 @@ export interface UpdateVolumeResponse {
     };
 }
 export declare const UpdateVolumeResponse: S.Schema<UpdateVolumeResponse>;
-declare const BadRequest_base: S.ErrorClass<BadRequest, S.TaggedStruct<"BadRequest", {
+declare const BadRequest_base: S.Class<BadRequest, S.TaggedStruct<"BadRequest", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BadRequest extends BadRequest_base {
 }
-declare const FileSystemNotFound_base: S.ErrorClass<FileSystemNotFound, S.TaggedStruct<"FileSystemNotFound", {
+declare const FileSystemNotFound_base: S.Class<FileSystemNotFound, S.TaggedStruct<"FileSystemNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileSystemNotFound extends FileSystemNotFound_base {
 }
-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 DataRepositoryTaskEnded_base: S.ErrorClass<DataRepositoryTaskEnded, S.TaggedStruct<"DataRepositoryTaskEnded", {
+declare const DataRepositoryTaskEnded_base: S.Class<DataRepositoryTaskEnded, S.TaggedStruct<"DataRepositoryTaskEnded", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DataRepositoryTaskEnded extends DataRepositoryTaskEnded_base {
 }
-declare const DataRepositoryTaskNotFound_base: S.ErrorClass<DataRepositoryTaskNotFound, S.TaggedStruct<"DataRepositoryTaskNotFound", {
+declare const DataRepositoryTaskNotFound_base: S.Class<DataRepositoryTaskNotFound, S.TaggedStruct<"DataRepositoryTaskNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DataRepositoryTaskNotFound extends DataRepositoryTaskNotFound_base {
 }
-declare const UnsupportedOperation_base: S.ErrorClass<UnsupportedOperation, S.TaggedStruct<"UnsupportedOperation", {
+declare const UnsupportedOperation_base: S.Class<UnsupportedOperation, S.TaggedStruct<"UnsupportedOperation", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperation extends UnsupportedOperation_base {
 }
-declare const BackupNotFound_base: S.ErrorClass<BackupNotFound, S.TaggedStruct<"BackupNotFound", {
+declare const BackupNotFound_base: S.Class<BackupNotFound, S.TaggedStruct<"BackupNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupNotFound extends BackupNotFound_base {
 }
-declare const IncompatibleParameterError_base: S.ErrorClass<IncompatibleParameterError, S.TaggedStruct<"IncompatibleParameterError", {
+declare const IncompatibleParameterError_base: S.Class<IncompatibleParameterError, S.TaggedStruct<"IncompatibleParameterError", {
     readonly Parameter: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IncompatibleParameterError extends IncompatibleParameterError_base {
 }
-declare const IncompatibleRegionForMultiAZ_base: S.ErrorClass<IncompatibleRegionForMultiAZ, S.TaggedStruct<"IncompatibleRegionForMultiAZ", {
+declare const IncompatibleRegionForMultiAZ_base: S.Class<IncompatibleRegionForMultiAZ, S.TaggedStruct<"IncompatibleRegionForMultiAZ", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IncompatibleRegionForMultiAZ extends IncompatibleRegionForMultiAZ_base {
 }
-declare const InvalidDestinationKmsKey_base: S.ErrorClass<InvalidDestinationKmsKey, S.TaggedStruct<"InvalidDestinationKmsKey", {
+declare const InvalidDestinationKmsKey_base: S.Class<InvalidDestinationKmsKey, S.TaggedStruct<"InvalidDestinationKmsKey", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDestinationKmsKey extends InvalidDestinationKmsKey_base {
 }
-declare const InvalidRegion_base: S.ErrorClass<InvalidRegion, S.TaggedStruct<"InvalidRegion", {
+declare const InvalidRegion_base: S.Class<InvalidRegion, S.TaggedStruct<"InvalidRegion", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRegion extends InvalidRegion_base {
 }
-declare const InvalidSourceKmsKey_base: S.ErrorClass<InvalidSourceKmsKey, S.TaggedStruct<"InvalidSourceKmsKey", {
+declare const InvalidSourceKmsKey_base: S.Class<InvalidSourceKmsKey, S.TaggedStruct<"InvalidSourceKmsKey", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSourceKmsKey extends InvalidSourceKmsKey_base {
 }
-declare const ServiceLimitExceeded_base: S.ErrorClass<ServiceLimitExceeded, S.TaggedStruct<"ServiceLimitExceeded", {
+declare const ServiceLimitExceeded_base: S.Class<ServiceLimitExceeded, S.TaggedStruct<"ServiceLimitExceeded", {
     readonly Limit: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3591,13 +3591,13 @@ declare const ServiceLimitExceeded_base: S.ErrorClass<ServiceLimitExceeded, S.Ta
 });
 export declare class ServiceLimitExceeded extends ServiceLimitExceeded_base {
 }
-declare const SourceBackupUnavailable_base: S.ErrorClass<SourceBackupUnavailable, S.TaggedStruct<"SourceBackupUnavailable", {
+declare const SourceBackupUnavailable_base: S.Class<SourceBackupUnavailable, S.TaggedStruct<"SourceBackupUnavailable", {
     readonly Message: S.optional<S.String>;
     readonly BackupId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SourceBackupUnavailable extends SourceBackupUnavailable_base {
 }
-declare const AccessPointAlreadyOwnedByYou_base: S.ErrorClass<AccessPointAlreadyOwnedByYou, S.TaggedStruct<"AccessPointAlreadyOwnedByYou", {
+declare const AccessPointAlreadyOwnedByYou_base: S.Class<AccessPointAlreadyOwnedByYou, S.TaggedStruct<"AccessPointAlreadyOwnedByYou", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3607,7 +3607,7 @@ declare const AccessPointAlreadyOwnedByYou_base: S.ErrorClass<AccessPointAlready
 });
 export declare class AccessPointAlreadyOwnedByYou extends AccessPointAlreadyOwnedByYou_base {
 }
-declare const InvalidAccessPoint_base: S.ErrorClass<InvalidAccessPoint, S.TaggedStruct<"InvalidAccessPoint", {
+declare const InvalidAccessPoint_base: S.Class<InvalidAccessPoint, S.TaggedStruct<"InvalidAccessPoint", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3617,7 +3617,7 @@ declare const InvalidAccessPoint_base: S.ErrorClass<InvalidAccessPoint, S.Tagged
 });
 export declare class InvalidAccessPoint extends InvalidAccessPoint_base {
 }
-declare const InvalidRequest_base: S.ErrorClass<InvalidRequest, S.TaggedStruct<"InvalidRequest", {
+declare const InvalidRequest_base: S.Class<InvalidRequest, S.TaggedStruct<"InvalidRequest", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3627,7 +3627,7 @@ declare const InvalidRequest_base: S.ErrorClass<InvalidRequest, S.TaggedStruct<"
 });
 export declare class InvalidRequest extends InvalidRequest_base {
 }
-declare const TooManyAccessPoints_base: S.ErrorClass<TooManyAccessPoints, S.TaggedStruct<"TooManyAccessPoints", {
+declare const TooManyAccessPoints_base: S.Class<TooManyAccessPoints, S.TaggedStruct<"TooManyAccessPoints", {
     readonly ErrorCode: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -3637,22 +3637,22 @@ declare const TooManyAccessPoints_base: S.ErrorClass<TooManyAccessPoints, S.Tagg
 });
 export declare class TooManyAccessPoints extends TooManyAccessPoints_base {
 }
-declare const VolumeNotFound_base: S.ErrorClass<VolumeNotFound, S.TaggedStruct<"VolumeNotFound", {
+declare const VolumeNotFound_base: S.Class<VolumeNotFound, S.TaggedStruct<"VolumeNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class VolumeNotFound extends VolumeNotFound_base {
 }
-declare const BackupInProgress_base: S.ErrorClass<BackupInProgress, S.TaggedStruct<"BackupInProgress", {
+declare const BackupInProgress_base: S.Class<BackupInProgress, S.TaggedStruct<"BackupInProgress", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupInProgress extends BackupInProgress_base {
 }
-declare const DataRepositoryTaskExecuting_base: S.ErrorClass<DataRepositoryTaskExecuting, S.TaggedStruct<"DataRepositoryTaskExecuting", {
+declare const DataRepositoryTaskExecuting_base: S.Class<DataRepositoryTaskExecuting, S.TaggedStruct<"DataRepositoryTaskExecuting", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DataRepositoryTaskExecuting extends DataRepositoryTaskExecuting_base {
 }
-declare const InvalidNetworkSettings_base: S.ErrorClass<InvalidNetworkSettings, S.TaggedStruct<"InvalidNetworkSettings", {
+declare const InvalidNetworkSettings_base: S.Class<InvalidNetworkSettings, S.TaggedStruct<"InvalidNetworkSettings", {
     readonly Message: S.optional<S.String>;
     readonly InvalidSubnetId: S.optional<S.String>;
     readonly InvalidSecurityGroupId: S.optional<S.String>;
@@ -3660,98 +3660,98 @@ declare const InvalidNetworkSettings_base: S.ErrorClass<InvalidNetworkSettings,
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNetworkSettings extends InvalidNetworkSettings_base {
 }
-declare const InvalidPerUnitStorageThroughput_base: S.ErrorClass<InvalidPerUnitStorageThroughput, S.TaggedStruct<"InvalidPerUnitStorageThroughput", {
+declare const InvalidPerUnitStorageThroughput_base: S.Class<InvalidPerUnitStorageThroughput, S.TaggedStruct<"InvalidPerUnitStorageThroughput", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPerUnitStorageThroughput extends InvalidPerUnitStorageThroughput_base {
 }
-declare const MissingFileCacheConfiguration_base: S.ErrorClass<MissingFileCacheConfiguration, S.TaggedStruct<"MissingFileCacheConfiguration", {
+declare const MissingFileCacheConfiguration_base: S.Class<MissingFileCacheConfiguration, S.TaggedStruct<"MissingFileCacheConfiguration", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MissingFileCacheConfiguration extends MissingFileCacheConfiguration_base {
 }
-declare const ActiveDirectoryError_base: S.ErrorClass<ActiveDirectoryError, S.TaggedStruct<"ActiveDirectoryError", {
+declare const ActiveDirectoryError_base: S.Class<ActiveDirectoryError, S.TaggedStruct<"ActiveDirectoryError", {
     readonly ActiveDirectoryId: S.optional<S.String>;
     readonly Type: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActiveDirectoryError extends ActiveDirectoryError_base {
 }
-declare const InvalidExportPath_base: S.ErrorClass<InvalidExportPath, S.TaggedStruct<"InvalidExportPath", {
+declare const InvalidExportPath_base: S.Class<InvalidExportPath, S.TaggedStruct<"InvalidExportPath", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExportPath extends InvalidExportPath_base {
 }
-declare const InvalidImportPath_base: S.ErrorClass<InvalidImportPath, S.TaggedStruct<"InvalidImportPath", {
+declare const InvalidImportPath_base: S.Class<InvalidImportPath, S.TaggedStruct<"InvalidImportPath", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidImportPath extends InvalidImportPath_base {
 }
-declare const MissingFileSystemConfiguration_base: S.ErrorClass<MissingFileSystemConfiguration, S.TaggedStruct<"MissingFileSystemConfiguration", {
+declare const MissingFileSystemConfiguration_base: S.Class<MissingFileSystemConfiguration, S.TaggedStruct<"MissingFileSystemConfiguration", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MissingFileSystemConfiguration extends MissingFileSystemConfiguration_base {
 }
-declare const MissingVolumeConfiguration_base: S.ErrorClass<MissingVolumeConfiguration, S.TaggedStruct<"MissingVolumeConfiguration", {
+declare const MissingVolumeConfiguration_base: S.Class<MissingVolumeConfiguration, S.TaggedStruct<"MissingVolumeConfiguration", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MissingVolumeConfiguration extends MissingVolumeConfiguration_base {
 }
-declare const StorageVirtualMachineNotFound_base: S.ErrorClass<StorageVirtualMachineNotFound, S.TaggedStruct<"StorageVirtualMachineNotFound", {
+declare const StorageVirtualMachineNotFound_base: S.Class<StorageVirtualMachineNotFound, S.TaggedStruct<"StorageVirtualMachineNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StorageVirtualMachineNotFound extends StorageVirtualMachineNotFound_base {
 }
-declare const BackupBeingCopied_base: S.ErrorClass<BackupBeingCopied, S.TaggedStruct<"BackupBeingCopied", {
+declare const BackupBeingCopied_base: S.Class<BackupBeingCopied, S.TaggedStruct<"BackupBeingCopied", {
     readonly Message: S.optional<S.String>;
     readonly BackupId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupBeingCopied extends BackupBeingCopied_base {
 }
-declare const BackupRestoring_base: S.ErrorClass<BackupRestoring, S.TaggedStruct<"BackupRestoring", {
+declare const BackupRestoring_base: S.Class<BackupRestoring, S.TaggedStruct<"BackupRestoring", {
     readonly Message: S.optional<S.String>;
     readonly FileSystemId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BackupRestoring extends BackupRestoring_base {
 }
-declare const DataRepositoryAssociationNotFound_base: S.ErrorClass<DataRepositoryAssociationNotFound, S.TaggedStruct<"DataRepositoryAssociationNotFound", {
+declare const DataRepositoryAssociationNotFound_base: S.Class<DataRepositoryAssociationNotFound, S.TaggedStruct<"DataRepositoryAssociationNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DataRepositoryAssociationNotFound extends DataRepositoryAssociationNotFound_base {
 }
-declare const FileCacheNotFound_base: S.ErrorClass<FileCacheNotFound, S.TaggedStruct<"FileCacheNotFound", {
+declare const FileCacheNotFound_base: S.Class<FileCacheNotFound, S.TaggedStruct<"FileCacheNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileCacheNotFound extends FileCacheNotFound_base {
 }
-declare const SnapshotNotFound_base: S.ErrorClass<SnapshotNotFound, S.TaggedStruct<"SnapshotNotFound", {
+declare const SnapshotNotFound_base: S.Class<SnapshotNotFound, S.TaggedStruct<"SnapshotNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SnapshotNotFound extends SnapshotNotFound_base {
 }
-declare const InvalidDataRepositoryType_base: S.ErrorClass<InvalidDataRepositoryType, S.TaggedStruct<"InvalidDataRepositoryType", {
+declare const InvalidDataRepositoryType_base: S.Class<InvalidDataRepositoryType, S.TaggedStruct<"InvalidDataRepositoryType", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDataRepositoryType extends InvalidDataRepositoryType_base {
 }
-declare const S3AccessPointAttachmentNotFound_base: S.ErrorClass<S3AccessPointAttachmentNotFound, S.TaggedStruct<"S3AccessPointAttachmentNotFound", {
+declare const S3AccessPointAttachmentNotFound_base: S.Class<S3AccessPointAttachmentNotFound, S.TaggedStruct<"S3AccessPointAttachmentNotFound", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class S3AccessPointAttachmentNotFound extends S3AccessPointAttachmentNotFound_base {
 }
-declare const NotServiceResourceError_base: S.ErrorClass<NotServiceResourceError, S.TaggedStruct<"NotServiceResourceError", {
+declare const NotServiceResourceError_base: S.Class<NotServiceResourceError, S.TaggedStruct<"NotServiceResourceError", {
     readonly ResourceARN: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotServiceResourceError extends NotServiceResourceError_base {
 }
-declare const ResourceDoesNotSupportTagging_base: S.ErrorClass<ResourceDoesNotSupportTagging, S.TaggedStruct<"ResourceDoesNotSupportTagging", {
+declare const ResourceDoesNotSupportTagging_base: S.Class<ResourceDoesNotSupportTagging, S.TaggedStruct<"ResourceDoesNotSupportTagging", {
     readonly ResourceARN: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceDoesNotSupportTagging extends ResourceDoesNotSupportTagging_base {
 }
-declare const ResourceNotFound_base: S.ErrorClass<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
+declare const ResourceNotFound_base: S.Class<ResourceNotFound, S.TaggedStruct<"ResourceNotFound", {
     readonly ResourceARN: S.optional<S.String>;
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/gamelift.d.ts

@@ -2925,37 +2925,37 @@ export interface ValidateMatchmakingRuleSetOutput {
     Valid?: boolean;
 }
 export declare const ValidateMatchmakingRuleSetOutput: S.Schema<ValidateMatchmakingRuleSetOutput>;
-declare const InternalServiceException_base: S.ErrorClass<InternalServiceException, S.TaggedStruct<"InternalServiceException", {
+declare const InternalServiceException_base: S.Class<InternalServiceException, S.TaggedStruct<"InternalServiceException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServiceException extends InternalServiceException_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 NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedStruct<"NotFoundException", {
+declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotFoundException extends NotFoundException_base {
 }
-declare const UnsupportedRegionException_base: S.ErrorClass<UnsupportedRegionException, S.TaggedStruct<"UnsupportedRegionException", {
+declare const UnsupportedRegionException_base: S.Class<UnsupportedRegionException, S.TaggedStruct<"UnsupportedRegionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedRegionException extends UnsupportedRegionException_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>;
 export declare class ConflictException extends ConflictException_base {
 }
-declare const OutOfCapacityException_base: S.ErrorClass<OutOfCapacityException, S.TaggedStruct<"OutOfCapacityException", {
+declare const OutOfCapacityException_base: S.Class<OutOfCapacityException, S.TaggedStruct<"OutOfCapacityException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OutOfCapacityException extends OutOfCapacityException_base {
 }
-declare const UnauthorizedException_base: S.ErrorClass<UnauthorizedException, S.TaggedStruct<"UnauthorizedException", {
+declare const UnauthorizedException_base: S.Class<UnauthorizedException, S.TaggedStruct<"UnauthorizedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2964,47 +2964,47 @@ declare const UnauthorizedException_base: S.ErrorClass<UnauthorizedException, S.
 });
 export declare class UnauthorizedException extends UnauthorizedException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_base {
 }
-declare const TaggingFailedException_base: S.ErrorClass<TaggingFailedException, S.TaggedStruct<"TaggingFailedException", {
+declare const TaggingFailedException_base: S.Class<TaggingFailedException, S.TaggedStruct<"TaggingFailedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TaggingFailedException extends TaggingFailedException_base {
 }
-declare const NotReadyException_base: S.ErrorClass<NotReadyException, S.TaggedStruct<"NotReadyException", {
+declare const NotReadyException_base: S.Class<NotReadyException, S.TaggedStruct<"NotReadyException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotReadyException extends NotReadyException_base {
 }
-declare const InvalidFleetStatusException_base: S.ErrorClass<InvalidFleetStatusException, S.TaggedStruct<"InvalidFleetStatusException", {
+declare const InvalidFleetStatusException_base: S.Class<InvalidFleetStatusException, S.TaggedStruct<"InvalidFleetStatusException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFleetStatusException extends InvalidFleetStatusException_base {
 }
-declare const FleetCapacityExceededException_base: S.ErrorClass<FleetCapacityExceededException, S.TaggedStruct<"FleetCapacityExceededException", {
+declare const FleetCapacityExceededException_base: S.Class<FleetCapacityExceededException, S.TaggedStruct<"FleetCapacityExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FleetCapacityExceededException extends FleetCapacityExceededException_base {
 }
-declare const IdempotentParameterMismatchException_base: S.ErrorClass<IdempotentParameterMismatchException, S.TaggedStruct<"IdempotentParameterMismatchException", {
+declare const IdempotentParameterMismatchException_base: S.Class<IdempotentParameterMismatchException, S.TaggedStruct<"IdempotentParameterMismatchException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IdempotentParameterMismatchException extends IdempotentParameterMismatchException_base {
 }
-declare const TerminalRoutingStrategyException_base: S.ErrorClass<TerminalRoutingStrategyException, S.TaggedStruct<"TerminalRoutingStrategyException", {
+declare const TerminalRoutingStrategyException_base: S.Class<TerminalRoutingStrategyException, S.TaggedStruct<"TerminalRoutingStrategyException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TerminalRoutingStrategyException extends TerminalRoutingStrategyException_base {
 }
-declare const GameSessionFullException_base: S.ErrorClass<GameSessionFullException, S.TaggedStruct<"GameSessionFullException", {
+declare const GameSessionFullException_base: S.Class<GameSessionFullException, S.TaggedStruct<"GameSessionFullException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class GameSessionFullException extends GameSessionFullException_base {
 }
-declare const InvalidGameSessionStatusException_base: S.ErrorClass<InvalidGameSessionStatusException, S.TaggedStruct<"InvalidGameSessionStatusException", {
+declare const InvalidGameSessionStatusException_base: S.Class<InvalidGameSessionStatusException, S.TaggedStruct<"InvalidGameSessionStatusException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidGameSessionStatusException extends InvalidGameSessionStatusException_base {

package/lib/services/gameliftstreams.d.ts

@@ -543,7 +543,7 @@ export interface ListStreamGroupsOutput {
     NextToken?: string;
 }
 export declare const ListStreamGroupsOutput: S.Schema<ListStreamGroupsOutput>;
-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": {
@@ -552,7 +552,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": {
@@ -565,7 +565,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": {
@@ -574,7 +574,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": {
@@ -583,7 +583,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;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -596,7 +596,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": {
@@ -605,7 +605,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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": {

package/lib/services/geo-maps.d.ts

@@ -135,7 +135,7 @@ export interface GetTileResponse {
     PricingBucket: string;
 }
 export declare const GetTileResponse: S.Schema<GetTileResponse>;
-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": {
@@ -144,7 +144,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": {
@@ -157,7 +157,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -170,7 +170,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.String;
     readonly FieldList: S.$Array<S.Schema<ValidationExceptionField>>;
@@ -181,7 +181,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;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/geo-places.d.ts

@@ -761,7 +761,7 @@ export interface SuggestResponse {
     QueryRefinements?: QueryRefinement[];
 }
 export declare const SuggestResponse: S.Schema<SuggestResponse>;
-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": {
@@ -770,7 +770,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": {
@@ -783,7 +783,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -796,7 +796,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.String;
     readonly FieldList: S.$Array<S.Schema<ValidationExceptionField>>;

package/lib/services/geo-routes.d.ts

@@ -1631,7 +1631,7 @@ export interface SnapToRoadsResponse {
     SnappedTracePoints: RoadSnapSnappedTracePoint[];
 }
 export declare const SnapToRoadsResponse: S.Schema<SnapToRoadsResponse>;
-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": {
@@ -1640,7 +1640,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": {
@@ -1653,7 +1653,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.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1666,7 +1666,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.String;
     readonly FieldList: S.$Array<S.Schema<ValidationExceptionField>>;