@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/config-service.d.ts

@@ -2173,72 +2173,72 @@ export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
 export interface UntagResourceResponse {
 }
 export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
-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 NoSuchConfigurationRecorderException_base: S.ErrorClass<NoSuchConfigurationRecorderException, S.TaggedStruct<"NoSuchConfigurationRecorderException", {
+declare const NoSuchConfigurationRecorderException_base: S.Class<NoSuchConfigurationRecorderException, S.TaggedStruct<"NoSuchConfigurationRecorderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConfigurationRecorderException extends NoSuchConfigurationRecorderException_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 NoSuchConfigurationAggregatorException_base: S.ErrorClass<NoSuchConfigurationAggregatorException, S.TaggedStruct<"NoSuchConfigurationAggregatorException", {
+declare const NoSuchConfigurationAggregatorException_base: S.Class<NoSuchConfigurationAggregatorException, S.TaggedStruct<"NoSuchConfigurationAggregatorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConfigurationAggregatorException extends NoSuchConfigurationAggregatorException_base {
 }
-declare const NoAvailableConfigurationRecorderException_base: S.ErrorClass<NoAvailableConfigurationRecorderException, S.TaggedStruct<"NoAvailableConfigurationRecorderException", {
+declare const NoAvailableConfigurationRecorderException_base: S.Class<NoAvailableConfigurationRecorderException, S.TaggedStruct<"NoAvailableConfigurationRecorderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoAvailableConfigurationRecorderException extends NoAvailableConfigurationRecorderException_base {
 }
-declare const InvalidParameterValueException_base: S.ErrorClass<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
+declare const InvalidParameterValueException_base: S.Class<InvalidParameterValueException, S.TaggedStruct<"InvalidParameterValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterValueException extends InvalidParameterValueException_base {
 }
-declare const NoSuchConfigRuleException_base: S.ErrorClass<NoSuchConfigRuleException, S.TaggedStruct<"NoSuchConfigRuleException", {
+declare const NoSuchConfigRuleException_base: S.Class<NoSuchConfigRuleException, S.TaggedStruct<"NoSuchConfigRuleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConfigRuleException extends NoSuchConfigRuleException_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 UnmodifiableEntityException_base: S.ErrorClass<UnmodifiableEntityException, S.TaggedStruct<"UnmodifiableEntityException", {
+declare const UnmodifiableEntityException_base: S.Class<UnmodifiableEntityException, S.TaggedStruct<"UnmodifiableEntityException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnmodifiableEntityException extends UnmodifiableEntityException_base {
 }
-declare const NoSuchConformancePackException_base: S.ErrorClass<NoSuchConformancePackException, S.TaggedStruct<"NoSuchConformancePackException", {
+declare const NoSuchConformancePackException_base: S.Class<NoSuchConformancePackException, S.TaggedStruct<"NoSuchConformancePackException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConformancePackException extends NoSuchConformancePackException_base {
 }
-declare const LastDeliveryChannelDeleteFailedException_base: S.ErrorClass<LastDeliveryChannelDeleteFailedException, S.TaggedStruct<"LastDeliveryChannelDeleteFailedException", {
+declare const LastDeliveryChannelDeleteFailedException_base: S.Class<LastDeliveryChannelDeleteFailedException, S.TaggedStruct<"LastDeliveryChannelDeleteFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LastDeliveryChannelDeleteFailedException extends LastDeliveryChannelDeleteFailedException_base {
 }
-declare const NoSuchDeliveryChannelException_base: S.ErrorClass<NoSuchDeliveryChannelException, S.TaggedStruct<"NoSuchDeliveryChannelException", {
+declare const NoSuchDeliveryChannelException_base: S.Class<NoSuchDeliveryChannelException, S.TaggedStruct<"NoSuchDeliveryChannelException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchDeliveryChannelException extends NoSuchDeliveryChannelException_base {
 }
-declare const NoSuchOrganizationConfigRuleException_base: S.ErrorClass<NoSuchOrganizationConfigRuleException, S.TaggedStruct<"NoSuchOrganizationConfigRuleException", {
+declare const NoSuchOrganizationConfigRuleException_base: S.Class<NoSuchOrganizationConfigRuleException, S.TaggedStruct<"NoSuchOrganizationConfigRuleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchOrganizationConfigRuleException extends NoSuchOrganizationConfigRuleException_base {
 }
-declare const OrganizationAccessDeniedException_base: S.ErrorClass<OrganizationAccessDeniedException, S.TaggedStruct<"OrganizationAccessDeniedException", {
+declare const OrganizationAccessDeniedException_base: S.Class<OrganizationAccessDeniedException, S.TaggedStruct<"OrganizationAccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2247,212 +2247,212 @@ declare const OrganizationAccessDeniedException_base: S.ErrorClass<OrganizationA
 });
 export declare class OrganizationAccessDeniedException extends OrganizationAccessDeniedException_base {
 }
-declare const NoSuchOrganizationConformancePackException_base: S.ErrorClass<NoSuchOrganizationConformancePackException, S.TaggedStruct<"NoSuchOrganizationConformancePackException", {
+declare const NoSuchOrganizationConformancePackException_base: S.Class<NoSuchOrganizationConformancePackException, S.TaggedStruct<"NoSuchOrganizationConformancePackException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchOrganizationConformancePackException extends NoSuchOrganizationConformancePackException_base {
 }
-declare const InsufficientPermissionsException_base: S.ErrorClass<InsufficientPermissionsException, S.TaggedStruct<"InsufficientPermissionsException", {
+declare const InsufficientPermissionsException_base: S.Class<InsufficientPermissionsException, S.TaggedStruct<"InsufficientPermissionsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InsufficientPermissionsException extends InsufficientPermissionsException_base {
 }
-declare const NoSuchRemediationConfigurationException_base: S.ErrorClass<NoSuchRemediationConfigurationException, S.TaggedStruct<"NoSuchRemediationConfigurationException", {
+declare const NoSuchRemediationConfigurationException_base: S.Class<NoSuchRemediationConfigurationException, S.TaggedStruct<"NoSuchRemediationConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchRemediationConfigurationException extends NoSuchRemediationConfigurationException_base {
 }
-declare const RemediationInProgressException_base: S.ErrorClass<RemediationInProgressException, S.TaggedStruct<"RemediationInProgressException", {
+declare const RemediationInProgressException_base: S.Class<RemediationInProgressException, S.TaggedStruct<"RemediationInProgressException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RemediationInProgressException extends RemediationInProgressException_base {
 }
-declare const NoSuchRemediationExceptionException_base: S.ErrorClass<NoSuchRemediationExceptionException, S.TaggedStruct<"NoSuchRemediationExceptionException", {
+declare const NoSuchRemediationExceptionException_base: S.Class<NoSuchRemediationExceptionException, S.TaggedStruct<"NoSuchRemediationExceptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchRemediationExceptionException extends NoSuchRemediationExceptionException_base {
 }
-declare const NoRunningConfigurationRecorderException_base: S.ErrorClass<NoRunningConfigurationRecorderException, S.TaggedStruct<"NoRunningConfigurationRecorderException", {
+declare const NoRunningConfigurationRecorderException_base: S.Class<NoRunningConfigurationRecorderException, S.TaggedStruct<"NoRunningConfigurationRecorderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoRunningConfigurationRecorderException extends NoRunningConfigurationRecorderException_base {
 }
-declare const NoSuchRetentionConfigurationException_base: S.ErrorClass<NoSuchRetentionConfigurationException, S.TaggedStruct<"NoSuchRetentionConfigurationException", {
+declare const NoSuchRetentionConfigurationException_base: S.Class<NoSuchRetentionConfigurationException, S.TaggedStruct<"NoSuchRetentionConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchRetentionConfigurationException extends NoSuchRetentionConfigurationException_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 InvalidLimitException_base: S.ErrorClass<InvalidLimitException, S.TaggedStruct<"InvalidLimitException", {
+declare const InvalidLimitException_base: S.Class<InvalidLimitException, S.TaggedStruct<"InvalidLimitException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidLimitException extends InvalidLimitException_base {
 }
-declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
+declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const NoSuchConfigRuleInConformancePackException_base: S.ErrorClass<NoSuchConfigRuleInConformancePackException, S.TaggedStruct<"NoSuchConfigRuleInConformancePackException", {
+declare const NoSuchConfigRuleInConformancePackException_base: S.Class<NoSuchConfigRuleInConformancePackException, S.TaggedStruct<"NoSuchConfigRuleInConformancePackException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchConfigRuleInConformancePackException extends NoSuchConfigRuleInConformancePackException_base {
 }
-declare const OversizedConfigurationItemException_base: S.ErrorClass<OversizedConfigurationItemException, S.TaggedStruct<"OversizedConfigurationItemException", {
+declare const OversizedConfigurationItemException_base: S.Class<OversizedConfigurationItemException, S.TaggedStruct<"OversizedConfigurationItemException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OversizedConfigurationItemException extends OversizedConfigurationItemException_base {
 }
-declare const ResourceNotDiscoveredException_base: S.ErrorClass<ResourceNotDiscoveredException, S.TaggedStruct<"ResourceNotDiscoveredException", {
+declare const ResourceNotDiscoveredException_base: S.Class<ResourceNotDiscoveredException, S.TaggedStruct<"ResourceNotDiscoveredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotDiscoveredException extends ResourceNotDiscoveredException_base {
 }
-declare const InvalidTimeRangeException_base: S.ErrorClass<InvalidTimeRangeException, S.TaggedStruct<"InvalidTimeRangeException", {
+declare const InvalidTimeRangeException_base: S.Class<InvalidTimeRangeException, S.TaggedStruct<"InvalidTimeRangeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTimeRangeException extends InvalidTimeRangeException_base {
 }
-declare const MaxNumberOfConfigRulesExceededException_base: S.ErrorClass<MaxNumberOfConfigRulesExceededException, S.TaggedStruct<"MaxNumberOfConfigRulesExceededException", {
+declare const MaxNumberOfConfigRulesExceededException_base: S.Class<MaxNumberOfConfigRulesExceededException, S.TaggedStruct<"MaxNumberOfConfigRulesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfConfigRulesExceededException extends MaxNumberOfConfigRulesExceededException_base {
 }
-declare const InvalidRoleException_base: S.ErrorClass<InvalidRoleException, S.TaggedStruct<"InvalidRoleException", {
+declare const InvalidRoleException_base: S.Class<InvalidRoleException, S.TaggedStruct<"InvalidRoleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoleException extends InvalidRoleException_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 NoAvailableOrganizationException_base: S.ErrorClass<NoAvailableOrganizationException, S.TaggedStruct<"NoAvailableOrganizationException", {
+declare const NoAvailableOrganizationException_base: S.Class<NoAvailableOrganizationException, S.TaggedStruct<"NoAvailableOrganizationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoAvailableOrganizationException extends NoAvailableOrganizationException_base {
 }
-declare const OrganizationAllFeaturesNotEnabledException_base: S.ErrorClass<OrganizationAllFeaturesNotEnabledException, S.TaggedStruct<"OrganizationAllFeaturesNotEnabledException", {
+declare const OrganizationAllFeaturesNotEnabledException_base: S.Class<OrganizationAllFeaturesNotEnabledException, S.TaggedStruct<"OrganizationAllFeaturesNotEnabledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OrganizationAllFeaturesNotEnabledException extends OrganizationAllFeaturesNotEnabledException_base {
 }
-declare const InvalidConfigurationRecorderNameException_base: S.ErrorClass<InvalidConfigurationRecorderNameException, S.TaggedStruct<"InvalidConfigurationRecorderNameException", {
+declare const InvalidConfigurationRecorderNameException_base: S.Class<InvalidConfigurationRecorderNameException, S.TaggedStruct<"InvalidConfigurationRecorderNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidConfigurationRecorderNameException extends InvalidConfigurationRecorderNameException_base {
 }
-declare const InvalidRecordingGroupException_base: S.ErrorClass<InvalidRecordingGroupException, S.TaggedStruct<"InvalidRecordingGroupException", {
+declare const InvalidRecordingGroupException_base: S.Class<InvalidRecordingGroupException, S.TaggedStruct<"InvalidRecordingGroupException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRecordingGroupException extends InvalidRecordingGroupException_base {
 }
-declare const MaxNumberOfConfigurationRecordersExceededException_base: S.ErrorClass<MaxNumberOfConfigurationRecordersExceededException, S.TaggedStruct<"MaxNumberOfConfigurationRecordersExceededException", {
+declare const MaxNumberOfConfigurationRecordersExceededException_base: S.Class<MaxNumberOfConfigurationRecordersExceededException, S.TaggedStruct<"MaxNumberOfConfigurationRecordersExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfConfigurationRecordersExceededException extends MaxNumberOfConfigurationRecordersExceededException_base {
 }
-declare const ConformancePackTemplateValidationException_base: S.ErrorClass<ConformancePackTemplateValidationException, S.TaggedStruct<"ConformancePackTemplateValidationException", {
+declare const ConformancePackTemplateValidationException_base: S.Class<ConformancePackTemplateValidationException, S.TaggedStruct<"ConformancePackTemplateValidationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConformancePackTemplateValidationException extends ConformancePackTemplateValidationException_base {
 }
-declare const MaxNumberOfConformancePacksExceededException_base: S.ErrorClass<MaxNumberOfConformancePacksExceededException, S.TaggedStruct<"MaxNumberOfConformancePacksExceededException", {
+declare const MaxNumberOfConformancePacksExceededException_base: S.Class<MaxNumberOfConformancePacksExceededException, S.TaggedStruct<"MaxNumberOfConformancePacksExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfConformancePacksExceededException extends MaxNumberOfConformancePacksExceededException_base {
 }
-declare const InsufficientDeliveryPolicyException_base: S.ErrorClass<InsufficientDeliveryPolicyException, S.TaggedStruct<"InsufficientDeliveryPolicyException", {
+declare const InsufficientDeliveryPolicyException_base: S.Class<InsufficientDeliveryPolicyException, S.TaggedStruct<"InsufficientDeliveryPolicyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InsufficientDeliveryPolicyException extends InsufficientDeliveryPolicyException_base {
 }
-declare const InvalidDeliveryChannelNameException_base: S.ErrorClass<InvalidDeliveryChannelNameException, S.TaggedStruct<"InvalidDeliveryChannelNameException", {
+declare const InvalidDeliveryChannelNameException_base: S.Class<InvalidDeliveryChannelNameException, S.TaggedStruct<"InvalidDeliveryChannelNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeliveryChannelNameException extends InvalidDeliveryChannelNameException_base {
 }
-declare const InvalidS3KeyPrefixException_base: S.ErrorClass<InvalidS3KeyPrefixException, S.TaggedStruct<"InvalidS3KeyPrefixException", {
+declare const InvalidS3KeyPrefixException_base: S.Class<InvalidS3KeyPrefixException, S.TaggedStruct<"InvalidS3KeyPrefixException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidS3KeyPrefixException extends InvalidS3KeyPrefixException_base {
 }
-declare const InvalidS3KmsKeyArnException_base: S.ErrorClass<InvalidS3KmsKeyArnException, S.TaggedStruct<"InvalidS3KmsKeyArnException", {
+declare const InvalidS3KmsKeyArnException_base: S.Class<InvalidS3KmsKeyArnException, S.TaggedStruct<"InvalidS3KmsKeyArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidS3KmsKeyArnException extends InvalidS3KmsKeyArnException_base {
 }
-declare const InvalidSNSTopicARNException_base: S.ErrorClass<InvalidSNSTopicARNException, S.TaggedStruct<"InvalidSNSTopicARNException", {
+declare const InvalidSNSTopicARNException_base: S.Class<InvalidSNSTopicARNException, S.TaggedStruct<"InvalidSNSTopicARNException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSNSTopicARNException extends InvalidSNSTopicARNException_base {
 }
-declare const MaxNumberOfDeliveryChannelsExceededException_base: S.ErrorClass<MaxNumberOfDeliveryChannelsExceededException, S.TaggedStruct<"MaxNumberOfDeliveryChannelsExceededException", {
+declare const MaxNumberOfDeliveryChannelsExceededException_base: S.Class<MaxNumberOfDeliveryChannelsExceededException, S.TaggedStruct<"MaxNumberOfDeliveryChannelsExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfDeliveryChannelsExceededException extends MaxNumberOfDeliveryChannelsExceededException_base {
 }
-declare const NoSuchBucketException_base: S.ErrorClass<NoSuchBucketException, S.TaggedStruct<"NoSuchBucketException", {
+declare const NoSuchBucketException_base: S.Class<NoSuchBucketException, S.TaggedStruct<"NoSuchBucketException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchBucketException extends NoSuchBucketException_base {
 }
-declare const InvalidResultTokenException_base: S.ErrorClass<InvalidResultTokenException, S.TaggedStruct<"InvalidResultTokenException", {
+declare const InvalidResultTokenException_base: S.Class<InvalidResultTokenException, S.TaggedStruct<"InvalidResultTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResultTokenException extends InvalidResultTokenException_base {
 }
-declare const MaxNumberOfOrganizationConfigRulesExceededException_base: S.ErrorClass<MaxNumberOfOrganizationConfigRulesExceededException, S.TaggedStruct<"MaxNumberOfOrganizationConfigRulesExceededException", {
+declare const MaxNumberOfOrganizationConfigRulesExceededException_base: S.Class<MaxNumberOfOrganizationConfigRulesExceededException, S.TaggedStruct<"MaxNumberOfOrganizationConfigRulesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfOrganizationConfigRulesExceededException extends MaxNumberOfOrganizationConfigRulesExceededException_base {
 }
-declare const MaxNumberOfOrganizationConformancePacksExceededException_base: S.ErrorClass<MaxNumberOfOrganizationConformancePacksExceededException, S.TaggedStruct<"MaxNumberOfOrganizationConformancePacksExceededException", {
+declare const MaxNumberOfOrganizationConformancePacksExceededException_base: S.Class<MaxNumberOfOrganizationConformancePacksExceededException, S.TaggedStruct<"MaxNumberOfOrganizationConformancePacksExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfOrganizationConformancePacksExceededException extends MaxNumberOfOrganizationConformancePacksExceededException_base {
 }
-declare const OrganizationConformancePackTemplateValidationException_base: S.ErrorClass<OrganizationConformancePackTemplateValidationException, S.TaggedStruct<"OrganizationConformancePackTemplateValidationException", {
+declare const OrganizationConformancePackTemplateValidationException_base: S.Class<OrganizationConformancePackTemplateValidationException, S.TaggedStruct<"OrganizationConformancePackTemplateValidationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OrganizationConformancePackTemplateValidationException extends OrganizationConformancePackTemplateValidationException_base {
 }
-declare const MaxActiveResourcesExceededException_base: S.ErrorClass<MaxActiveResourcesExceededException, S.TaggedStruct<"MaxActiveResourcesExceededException", {
+declare const MaxActiveResourcesExceededException_base: S.Class<MaxActiveResourcesExceededException, S.TaggedStruct<"MaxActiveResourcesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxActiveResourcesExceededException extends MaxActiveResourcesExceededException_base {
 }
-declare const MaxNumberOfRetentionConfigurationsExceededException_base: S.ErrorClass<MaxNumberOfRetentionConfigurationsExceededException, S.TaggedStruct<"MaxNumberOfRetentionConfigurationsExceededException", {
+declare const MaxNumberOfRetentionConfigurationsExceededException_base: S.Class<MaxNumberOfRetentionConfigurationsExceededException, S.TaggedStruct<"MaxNumberOfRetentionConfigurationsExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaxNumberOfRetentionConfigurationsExceededException extends MaxNumberOfRetentionConfigurationsExceededException_base {
 }
-declare const ResourceConcurrentModificationException_base: S.ErrorClass<ResourceConcurrentModificationException, S.TaggedStruct<"ResourceConcurrentModificationException", {
+declare const ResourceConcurrentModificationException_base: S.Class<ResourceConcurrentModificationException, S.TaggedStruct<"ResourceConcurrentModificationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceConcurrentModificationException extends ResourceConcurrentModificationException_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 InvalidExpressionException_base: S.ErrorClass<InvalidExpressionException, S.TaggedStruct<"InvalidExpressionException", {
+declare const InvalidExpressionException_base: S.Class<InvalidExpressionException, S.TaggedStruct<"InvalidExpressionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExpressionException extends InvalidExpressionException_base {
 }
-declare const NoAvailableDeliveryChannelException_base: S.ErrorClass<NoAvailableDeliveryChannelException, S.TaggedStruct<"NoAvailableDeliveryChannelException", {
+declare const NoAvailableDeliveryChannelException_base: S.Class<NoAvailableDeliveryChannelException, S.TaggedStruct<"NoAvailableDeliveryChannelException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoAvailableDeliveryChannelException extends NoAvailableDeliveryChannelException_base {
 }
-declare const IdempotentParameterMismatch_base: S.ErrorClass<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {
+declare const IdempotentParameterMismatch_base: S.Class<IdempotentParameterMismatch, S.TaggedStruct<"IdempotentParameterMismatch", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/connect-contact-lens.d.ts

@@ -125,7 +125,7 @@ export interface ListRealtimeContactAnalysisSegmentsResponse {
     NextToken?: string;
 }
 export declare const ListRealtimeContactAnalysisSegmentsResponse: S.Schema<ListRealtimeContactAnalysisSegmentsResponse>;
-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": {
@@ -134,7 +134,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -143,7 +143,7 @@ declare const InternalServiceException_base: S.ErrorClass<InternalServiceExcepti
 });
 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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -152,7 +152,7 @@ declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException
 });
 export declare class InvalidRequestException extends InvalidRequestException_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": {
@@ -161,7 +161,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {