@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/kinesis-analytics.d.ts

@@ -577,7 +577,7 @@ export declare const UpdateApplicationRequest: S.Schema<UpdateApplicationRequest
 export interface UpdateApplicationResponse {
 }
 export declare const UpdateApplicationResponse: S.Schema<UpdateApplicationResponse>;
-declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
+declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -586,47 +586,47 @@ declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModif
 });
 export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidArgumentException extends InvalidArgumentException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const 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 UnsupportedOperationException_base: S.ErrorClass<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
+declare const UnsupportedOperationException_base: S.Class<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedOperationException extends UnsupportedOperationException_base {
 }
-declare const CodeValidationException_base: S.ErrorClass<CodeValidationException, S.TaggedStruct<"CodeValidationException", {
+declare const CodeValidationException_base: S.Class<CodeValidationException, S.TaggedStruct<"CodeValidationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CodeValidationException extends CodeValidationException_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 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>;
 export declare class TooManyTagsException extends TooManyTagsException_base {
 }
-declare const ResourceProvisionedThroughputExceededException_base: S.ErrorClass<ResourceProvisionedThroughputExceededException, S.TaggedStruct<"ResourceProvisionedThroughputExceededException", {
+declare const ResourceProvisionedThroughputExceededException_base: S.Class<ResourceProvisionedThroughputExceededException, S.TaggedStruct<"ResourceProvisionedThroughputExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceProvisionedThroughputExceededException extends ResourceProvisionedThroughputExceededException_base {
 }
-declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
+declare const ServiceUnavailableException_base: S.Class<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -635,14 +635,14 @@ declare const ServiceUnavailableException_base: S.ErrorClass<ServiceUnavailableE
 });
 export declare class ServiceUnavailableException extends ServiceUnavailableException_base {
 }
-declare const UnableToDetectSchemaException_base: S.ErrorClass<UnableToDetectSchemaException, S.TaggedStruct<"UnableToDetectSchemaException", {
+declare const UnableToDetectSchemaException_base: S.Class<UnableToDetectSchemaException, S.TaggedStruct<"UnableToDetectSchemaException", {
     readonly message: S.optional<S.String>;
     readonly RawInputRecords: S.optional<S.$Array<S.String>>;
     readonly ProcessedInputRecords: S.optional<S.$Array<S.String>>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnableToDetectSchemaException extends UnableToDetectSchemaException_base {
 }
-declare const InvalidApplicationConfigurationException_base: S.ErrorClass<InvalidApplicationConfigurationException, S.TaggedStruct<"InvalidApplicationConfigurationException", {
+declare const InvalidApplicationConfigurationException_base: S.Class<InvalidApplicationConfigurationException, S.TaggedStruct<"InvalidApplicationConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApplicationConfigurationException extends InvalidApplicationConfigurationException_base {

package/lib/services/kinesis-video-archived-media.d.ts

@@ -206,7 +206,7 @@ export interface ListFragmentsOutput {
     NextToken?: string;
 }
 export declare const ListFragmentsOutput: S.Schema<ListFragmentsOutput>;
-declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
+declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -215,7 +215,7 @@ declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceede
 });
 export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -224,7 +224,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_base {
 }
-declare const InvalidCodecPrivateDataException_base: S.ErrorClass<InvalidCodecPrivateDataException, S.TaggedStruct<"InvalidCodecPrivateDataException", {
+declare const InvalidCodecPrivateDataException_base: S.Class<InvalidCodecPrivateDataException, S.TaggedStruct<"InvalidCodecPrivateDataException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -233,7 +233,7 @@ declare const InvalidCodecPrivateDataException_base: S.ErrorClass<InvalidCodecPr
 });
 export declare class InvalidCodecPrivateDataException extends InvalidCodecPrivateDataException_base {
 }
-declare const InvalidMediaFrameException_base: S.ErrorClass<InvalidMediaFrameException, S.TaggedStruct<"InvalidMediaFrameException", {
+declare const InvalidMediaFrameException_base: S.Class<InvalidMediaFrameException, S.TaggedStruct<"InvalidMediaFrameException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -242,7 +242,7 @@ declare const InvalidMediaFrameException_base: S.ErrorClass<InvalidMediaFrameExc
 });
 export declare class InvalidMediaFrameException extends InvalidMediaFrameException_base {
 }
-declare const MissingCodecPrivateDataException_base: S.ErrorClass<MissingCodecPrivateDataException, S.TaggedStruct<"MissingCodecPrivateDataException", {
+declare const MissingCodecPrivateDataException_base: S.Class<MissingCodecPrivateDataException, S.TaggedStruct<"MissingCodecPrivateDataException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -251,7 +251,7 @@ declare const MissingCodecPrivateDataException_base: S.ErrorClass<MissingCodecPr
 });
 export declare class MissingCodecPrivateDataException extends MissingCodecPrivateDataException_base {
 }
-declare const NoDataRetentionException_base: S.ErrorClass<NoDataRetentionException, S.TaggedStruct<"NoDataRetentionException", {
+declare const NoDataRetentionException_base: S.Class<NoDataRetentionException, S.TaggedStruct<"NoDataRetentionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -260,7 +260,7 @@ declare const NoDataRetentionException_base: S.ErrorClass<NoDataRetentionExcepti
 });
 export declare class NoDataRetentionException extends NoDataRetentionException_base {
 }
-declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
+declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -269,7 +269,7 @@ declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException,
 });
 export declare class NotAuthorizedException extends NotAuthorizedException_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": {
@@ -278,7 +278,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const UnsupportedStreamMediaTypeException_base: S.ErrorClass<UnsupportedStreamMediaTypeException, S.TaggedStruct<"UnsupportedStreamMediaTypeException", {
+declare const UnsupportedStreamMediaTypeException_base: S.Class<UnsupportedStreamMediaTypeException, S.TaggedStruct<"UnsupportedStreamMediaTypeException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/kinesis-video-media.d.ts

@@ -31,7 +31,7 @@ export interface GetMediaOutput {
     Payload?: T.StreamingOutputBody;
 }
 export declare const GetMediaOutput: S.Schema<GetMediaOutput>;
-declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
+declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -40,7 +40,7 @@ declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceede
 });
 export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
 }
-declare const ConnectionLimitExceededException_base: S.ErrorClass<ConnectionLimitExceededException, S.TaggedStruct<"ConnectionLimitExceededException", {
+declare const ConnectionLimitExceededException_base: S.Class<ConnectionLimitExceededException, S.TaggedStruct<"ConnectionLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -49,7 +49,7 @@ declare const ConnectionLimitExceededException_base: S.ErrorClass<ConnectionLimi
 });
 export declare class ConnectionLimitExceededException extends ConnectionLimitExceededException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -58,7 +58,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_base {
 }
-declare const InvalidEndpointException_base: S.ErrorClass<InvalidEndpointException, S.TaggedStruct<"InvalidEndpointException", {
+declare const InvalidEndpointException_base: S.Class<InvalidEndpointException, S.TaggedStruct<"InvalidEndpointException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -67,7 +67,7 @@ declare const InvalidEndpointException_base: S.ErrorClass<InvalidEndpointExcepti
 });
 export declare class InvalidEndpointException extends InvalidEndpointException_base {
 }
-declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
+declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -76,7 +76,7 @@ declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException,
 });
 export declare class NotAuthorizedException extends NotAuthorizedException_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/kinesis-video-signaling.d.ts

@@ -47,7 +47,7 @@ export interface SendAlexaOfferToMasterResponse {
     Answer?: string;
 }
 export declare const SendAlexaOfferToMasterResponse: S.Schema<SendAlexaOfferToMasterResponse>;
-declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
+declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -56,7 +56,7 @@ declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceede
 });
 export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -65,7 +65,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_base {
 }
-declare const InvalidClientException_base: S.ErrorClass<InvalidClientException, S.TaggedStruct<"InvalidClientException", {
+declare const InvalidClientException_base: S.Class<InvalidClientException, S.TaggedStruct<"InvalidClientException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -74,7 +74,7 @@ declare const InvalidClientException_base: S.ErrorClass<InvalidClientException,
 });
 export declare class InvalidClientException extends InvalidClientException_base {
 }
-declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
+declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -83,7 +83,7 @@ declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException,
 });
 export declare class NotAuthorizedException extends NotAuthorizedException_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": {
@@ -92,7 +92,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const SessionExpiredException_base: S.ErrorClass<SessionExpiredException, S.TaggedStruct<"SessionExpiredException", {
+declare const SessionExpiredException_base: S.Class<SessionExpiredException, S.TaggedStruct<"SessionExpiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/kinesis-video-webrtc-storage.d.ts

@@ -21,7 +21,7 @@ export declare const JoinStorageSessionAsViewerInput: S.Schema<JoinStorageSessio
 export interface JoinStorageSessionAsViewerResponse {
 }
 export declare const JoinStorageSessionAsViewerResponse: S.Schema<JoinStorageSessionAsViewerResponse>;
-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": {
@@ -30,7 +30,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
+declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -39,7 +39,7 @@ declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceede
 });
 export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -48,7 +48,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_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/kinesis-video.d.ts

@@ -592,7 +592,7 @@ export declare const UpdateStreamStorageConfigurationInput: S.Schema<UpdateStrea
 export interface UpdateStreamStorageConfigurationOutput {
 }
 export declare const UpdateStreamStorageConfigurationOutput: S.Schema<UpdateStreamStorageConfigurationOutput>;
-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": {
@@ -601,7 +601,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const AccountChannelLimitExceededException_base: S.ErrorClass<AccountChannelLimitExceededException, S.TaggedStruct<"AccountChannelLimitExceededException", {
+declare const AccountChannelLimitExceededException_base: S.Class<AccountChannelLimitExceededException, S.TaggedStruct<"AccountChannelLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -610,7 +610,7 @@ declare const AccountChannelLimitExceededException_base: S.ErrorClass<AccountCha
 });
 export declare class AccountChannelLimitExceededException extends AccountChannelLimitExceededException_base {
 }
-declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
+declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -619,7 +619,7 @@ declare const ClientLimitExceededException_base: S.ErrorClass<ClientLimitExceede
 });
 export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -628,7 +628,7 @@ declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentExcepti
 });
 export declare class InvalidArgumentException extends InvalidArgumentException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -637,7 +637,7 @@ declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException,
 });
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const TagsPerResourceExceededLimitException_base: S.ErrorClass<TagsPerResourceExceededLimitException, S.TaggedStruct<"TagsPerResourceExceededLimitException", {
+declare const TagsPerResourceExceededLimitException_base: S.Class<TagsPerResourceExceededLimitException, S.TaggedStruct<"TagsPerResourceExceededLimitException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -646,7 +646,7 @@ declare const TagsPerResourceExceededLimitException_base: S.ErrorClass<TagsPerRe
 });
 export declare class TagsPerResourceExceededLimitException extends TagsPerResourceExceededLimitException_base {
 }
-declare const AccountStreamLimitExceededException_base: S.ErrorClass<AccountStreamLimitExceededException, S.TaggedStruct<"AccountStreamLimitExceededException", {
+declare const AccountStreamLimitExceededException_base: S.Class<AccountStreamLimitExceededException, S.TaggedStruct<"AccountStreamLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -655,7 +655,7 @@ declare const AccountStreamLimitExceededException_base: S.ErrorClass<AccountStre
 });
 export declare class AccountStreamLimitExceededException extends AccountStreamLimitExceededException_base {
 }
-declare const DeviceStreamLimitExceededException_base: S.ErrorClass<DeviceStreamLimitExceededException, S.TaggedStruct<"DeviceStreamLimitExceededException", {
+declare const DeviceStreamLimitExceededException_base: S.Class<DeviceStreamLimitExceededException, S.TaggedStruct<"DeviceStreamLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -664,7 +664,7 @@ declare const DeviceStreamLimitExceededException_base: S.ErrorClass<DeviceStream
 });
 export declare class DeviceStreamLimitExceededException extends DeviceStreamLimitExceededException_base {
 }
-declare const InvalidDeviceException_base: S.ErrorClass<InvalidDeviceException, S.TaggedStruct<"InvalidDeviceException", {
+declare const InvalidDeviceException_base: S.Class<InvalidDeviceException, S.TaggedStruct<"InvalidDeviceException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -673,7 +673,7 @@ declare const InvalidDeviceException_base: S.ErrorClass<InvalidDeviceException,
 });
 export declare class InvalidDeviceException extends InvalidDeviceException_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": {
@@ -682,7 +682,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const StreamEdgeConfigurationNotFoundException_base: S.ErrorClass<StreamEdgeConfigurationNotFoundException, S.TaggedStruct<"StreamEdgeConfigurationNotFoundException", {
+declare const StreamEdgeConfigurationNotFoundException_base: S.Class<StreamEdgeConfigurationNotFoundException, S.TaggedStruct<"StreamEdgeConfigurationNotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -691,7 +691,7 @@ declare const StreamEdgeConfigurationNotFoundException_base: S.ErrorClass<Stream
 });
 export declare class StreamEdgeConfigurationNotFoundException extends StreamEdgeConfigurationNotFoundException_base {
 }
-declare const VersionMismatchException_base: S.ErrorClass<VersionMismatchException, S.TaggedStruct<"VersionMismatchException", {
+declare const VersionMismatchException_base: S.Class<VersionMismatchException, S.TaggedStruct<"VersionMismatchException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -700,7 +700,7 @@ declare const VersionMismatchException_base: S.ErrorClass<VersionMismatchExcepti
 });
 export declare class VersionMismatchException extends VersionMismatchException_base {
 }
-declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
+declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -709,7 +709,7 @@ declare const NotAuthorizedException_base: S.ErrorClass<NotAuthorizedException,
 });
 export declare class NotAuthorizedException extends NotAuthorizedException_base {
 }
-declare const InvalidResourceFormatException_base: S.ErrorClass<InvalidResourceFormatException, S.TaggedStruct<"InvalidResourceFormatException", {
+declare const InvalidResourceFormatException_base: S.Class<InvalidResourceFormatException, S.TaggedStruct<"InvalidResourceFormatException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -718,7 +718,7 @@ declare const InvalidResourceFormatException_base: S.ErrorClass<InvalidResourceF
 });
 export declare class InvalidResourceFormatException extends InvalidResourceFormatException_base {
 }
-declare const NoDataRetentionException_base: S.ErrorClass<NoDataRetentionException, S.TaggedStruct<"NoDataRetentionException", {
+declare const NoDataRetentionException_base: S.Class<NoDataRetentionException, S.TaggedStruct<"NoDataRetentionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/kinesis.d.ts

@@ -785,7 +785,7 @@ export interface UpdateStreamWarmThroughputOutput {
     WarmThroughput?: WarmThroughputObject;
 }
 export declare const UpdateStreamWarmThroughputOutput: S.Schema<UpdateStreamWarmThroughputOutput>;
-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": {
@@ -794,42 +794,42 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InvalidArgumentException_base: S.ErrorClass<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
+declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidArgumentException extends InvalidArgumentException_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 ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const 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 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 ExpiredIteratorException_base: S.ErrorClass<ExpiredIteratorException, S.TaggedStruct<"ExpiredIteratorException", {
+declare const ExpiredIteratorException_base: S.Class<ExpiredIteratorException, S.TaggedStruct<"ExpiredIteratorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExpiredIteratorException extends ExpiredIteratorException_base {
 }
-declare const InternalFailureException_base: S.ErrorClass<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
+declare const InternalFailureException_base: S.Class<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalFailureException extends InternalFailureException_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": {
@@ -838,37 +838,37 @@ declare const KMSAccessDeniedException_base: S.ErrorClass<KMSAccessDeniedExcepti
 });
 export declare class KMSAccessDeniedException extends KMSAccessDeniedException_base {
 }
-declare const KMSDisabledException_base: S.ErrorClass<KMSDisabledException, S.TaggedStruct<"KMSDisabledException", {
+declare const KMSDisabledException_base: S.Class<KMSDisabledException, S.TaggedStruct<"KMSDisabledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSDisabledException extends KMSDisabledException_base {
 }
-declare const KMSInvalidStateException_base: S.ErrorClass<KMSInvalidStateException, S.TaggedStruct<"KMSInvalidStateException", {
+declare const KMSInvalidStateException_base: S.Class<KMSInvalidStateException, S.TaggedStruct<"KMSInvalidStateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSInvalidStateException extends KMSInvalidStateException_base {
 }
-declare const KMSNotFoundException_base: S.ErrorClass<KMSNotFoundException, S.TaggedStruct<"KMSNotFoundException", {
+declare const KMSNotFoundException_base: S.Class<KMSNotFoundException, S.TaggedStruct<"KMSNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSNotFoundException extends KMSNotFoundException_base {
 }
-declare const KMSOptInRequired_base: S.ErrorClass<KMSOptInRequired, S.TaggedStruct<"KMSOptInRequired", {
+declare const KMSOptInRequired_base: S.Class<KMSOptInRequired, S.TaggedStruct<"KMSOptInRequired", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class KMSOptInRequired extends KMSOptInRequired_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 ProvisionedThroughputExceededException_base: S.ErrorClass<ProvisionedThroughputExceededException, S.TaggedStruct<"ProvisionedThroughputExceededException", {
+declare const ProvisionedThroughputExceededException_base: S.Class<ProvisionedThroughputExceededException, S.TaggedStruct<"ProvisionedThroughputExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ProvisionedThroughputExceededException extends ProvisionedThroughputExceededException_base {
 }
-declare const ExpiredNextTokenException_base: S.ErrorClass<ExpiredNextTokenException, S.TaggedStruct<"ExpiredNextTokenException", {
+declare const ExpiredNextTokenException_base: S.Class<ExpiredNextTokenException, S.TaggedStruct<"ExpiredNextTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExpiredNextTokenException extends ExpiredNextTokenException_base {