@distilled.cloud/aws 0.7.12 → 0.9.0

package/lib/services/codecommit.d.ts

@@ -1554,22 +1554,22 @@ export declare const UpdateRepositoryNameInput: S.Schema<UpdateRepositoryNameInp
 export interface UpdateRepositoryNameResponse {
 }
 export declare const UpdateRepositoryNameResponse: S.Schema<UpdateRepositoryNameResponse>;
-declare const ApprovalRuleTemplateDoesNotExistException_base: S.ErrorClass<ApprovalRuleTemplateDoesNotExistException, S.TaggedStruct<"ApprovalRuleTemplateDoesNotExistException", {
+declare const ApprovalRuleTemplateDoesNotExistException_base: S.Class<ApprovalRuleTemplateDoesNotExistException, S.TaggedStruct<"ApprovalRuleTemplateDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleTemplateDoesNotExistException extends ApprovalRuleTemplateDoesNotExistException_base {
 }
-declare const ApprovalRuleTemplateNameRequiredException_base: S.ErrorClass<ApprovalRuleTemplateNameRequiredException, S.TaggedStruct<"ApprovalRuleTemplateNameRequiredException", {
+declare const ApprovalRuleTemplateNameRequiredException_base: S.Class<ApprovalRuleTemplateNameRequiredException, S.TaggedStruct<"ApprovalRuleTemplateNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleTemplateNameRequiredException extends ApprovalRuleTemplateNameRequiredException_base {
 }
-declare const EncryptionIntegrityChecksFailedException_base: S.ErrorClass<EncryptionIntegrityChecksFailedException, S.TaggedStruct<"EncryptionIntegrityChecksFailedException", {
+declare const EncryptionIntegrityChecksFailedException_base: S.Class<EncryptionIntegrityChecksFailedException, S.TaggedStruct<"EncryptionIntegrityChecksFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionIntegrityChecksFailedException extends EncryptionIntegrityChecksFailedException_base {
 }
-declare const EncryptionKeyAccessDeniedException_base: S.ErrorClass<EncryptionKeyAccessDeniedException, S.TaggedStruct<"EncryptionKeyAccessDeniedException", {
+declare const EncryptionKeyAccessDeniedException_base: S.Class<EncryptionKeyAccessDeniedException, S.TaggedStruct<"EncryptionKeyAccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1578,137 +1578,137 @@ declare const EncryptionKeyAccessDeniedException_base: S.ErrorClass<EncryptionKe
 });
 export declare class EncryptionKeyAccessDeniedException extends EncryptionKeyAccessDeniedException_base {
 }
-declare const EncryptionKeyDisabledException_base: S.ErrorClass<EncryptionKeyDisabledException, S.TaggedStruct<"EncryptionKeyDisabledException", {
+declare const EncryptionKeyDisabledException_base: S.Class<EncryptionKeyDisabledException, S.TaggedStruct<"EncryptionKeyDisabledException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyDisabledException extends EncryptionKeyDisabledException_base {
 }
-declare const EncryptionKeyNotFoundException_base: S.ErrorClass<EncryptionKeyNotFoundException, S.TaggedStruct<"EncryptionKeyNotFoundException", {
+declare const EncryptionKeyNotFoundException_base: S.Class<EncryptionKeyNotFoundException, S.TaggedStruct<"EncryptionKeyNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyNotFoundException extends EncryptionKeyNotFoundException_base {
 }
-declare const EncryptionKeyUnavailableException_base: S.ErrorClass<EncryptionKeyUnavailableException, S.TaggedStruct<"EncryptionKeyUnavailableException", {
+declare const EncryptionKeyUnavailableException_base: S.Class<EncryptionKeyUnavailableException, S.TaggedStruct<"EncryptionKeyUnavailableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyUnavailableException extends EncryptionKeyUnavailableException_base {
 }
-declare const InvalidApprovalRuleTemplateNameException_base: S.ErrorClass<InvalidApprovalRuleTemplateNameException, S.TaggedStruct<"InvalidApprovalRuleTemplateNameException", {
+declare const InvalidApprovalRuleTemplateNameException_base: S.Class<InvalidApprovalRuleTemplateNameException, S.TaggedStruct<"InvalidApprovalRuleTemplateNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalRuleTemplateNameException extends InvalidApprovalRuleTemplateNameException_base {
 }
-declare const InvalidRepositoryNameException_base: S.ErrorClass<InvalidRepositoryNameException, S.TaggedStruct<"InvalidRepositoryNameException", {
+declare const InvalidRepositoryNameException_base: S.Class<InvalidRepositoryNameException, S.TaggedStruct<"InvalidRepositoryNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryNameException extends InvalidRepositoryNameException_base {
 }
-declare const MaximumRuleTemplatesAssociatedWithRepositoryException_base: S.ErrorClass<MaximumRuleTemplatesAssociatedWithRepositoryException, S.TaggedStruct<"MaximumRuleTemplatesAssociatedWithRepositoryException", {
+declare const MaximumRuleTemplatesAssociatedWithRepositoryException_base: S.Class<MaximumRuleTemplatesAssociatedWithRepositoryException, S.TaggedStruct<"MaximumRuleTemplatesAssociatedWithRepositoryException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumRuleTemplatesAssociatedWithRepositoryException extends MaximumRuleTemplatesAssociatedWithRepositoryException_base {
 }
-declare const RepositoryDoesNotExistException_base: S.ErrorClass<RepositoryDoesNotExistException, S.TaggedStruct<"RepositoryDoesNotExistException", {
+declare const RepositoryDoesNotExistException_base: S.Class<RepositoryDoesNotExistException, S.TaggedStruct<"RepositoryDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryDoesNotExistException extends RepositoryDoesNotExistException_base {
 }
-declare const RepositoryNameRequiredException_base: S.ErrorClass<RepositoryNameRequiredException, S.TaggedStruct<"RepositoryNameRequiredException", {
+declare const RepositoryNameRequiredException_base: S.Class<RepositoryNameRequiredException, S.TaggedStruct<"RepositoryNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryNameRequiredException extends RepositoryNameRequiredException_base {
 }
-declare const MaximumRepositoryNamesExceededException_base: S.ErrorClass<MaximumRepositoryNamesExceededException, S.TaggedStruct<"MaximumRepositoryNamesExceededException", {
+declare const MaximumRepositoryNamesExceededException_base: S.Class<MaximumRepositoryNamesExceededException, S.TaggedStruct<"MaximumRepositoryNamesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumRepositoryNamesExceededException extends MaximumRepositoryNamesExceededException_base {
 }
-declare const RepositoryNamesRequiredException_base: S.ErrorClass<RepositoryNamesRequiredException, S.TaggedStruct<"RepositoryNamesRequiredException", {
+declare const RepositoryNamesRequiredException_base: S.Class<RepositoryNamesRequiredException, S.TaggedStruct<"RepositoryNamesRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryNamesRequiredException extends RepositoryNamesRequiredException_base {
 }
-declare const CommitDoesNotExistException_base: S.ErrorClass<CommitDoesNotExistException, S.TaggedStruct<"CommitDoesNotExistException", {
+declare const CommitDoesNotExistException_base: S.Class<CommitDoesNotExistException, S.TaggedStruct<"CommitDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitDoesNotExistException extends CommitDoesNotExistException_base {
 }
-declare const CommitRequiredException_base: S.ErrorClass<CommitRequiredException, S.TaggedStruct<"CommitRequiredException", {
+declare const CommitRequiredException_base: S.Class<CommitRequiredException, S.TaggedStruct<"CommitRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitRequiredException extends CommitRequiredException_base {
 }
-declare const InvalidCommitException_base: S.ErrorClass<InvalidCommitException, S.TaggedStruct<"InvalidCommitException", {
+declare const InvalidCommitException_base: S.Class<InvalidCommitException, S.TaggedStruct<"InvalidCommitException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCommitException extends InvalidCommitException_base {
 }
-declare const InvalidConflictDetailLevelException_base: S.ErrorClass<InvalidConflictDetailLevelException, S.TaggedStruct<"InvalidConflictDetailLevelException", {
+declare const InvalidConflictDetailLevelException_base: S.Class<InvalidConflictDetailLevelException, S.TaggedStruct<"InvalidConflictDetailLevelException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidConflictDetailLevelException extends InvalidConflictDetailLevelException_base {
 }
-declare const InvalidConflictResolutionStrategyException_base: S.ErrorClass<InvalidConflictResolutionStrategyException, S.TaggedStruct<"InvalidConflictResolutionStrategyException", {
+declare const InvalidConflictResolutionStrategyException_base: S.Class<InvalidConflictResolutionStrategyException, S.TaggedStruct<"InvalidConflictResolutionStrategyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidConflictResolutionStrategyException extends InvalidConflictResolutionStrategyException_base {
 }
-declare const InvalidContinuationTokenException_base: S.ErrorClass<InvalidContinuationTokenException, S.TaggedStruct<"InvalidContinuationTokenException", {
+declare const InvalidContinuationTokenException_base: S.Class<InvalidContinuationTokenException, S.TaggedStruct<"InvalidContinuationTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidContinuationTokenException extends InvalidContinuationTokenException_base {
 }
-declare const InvalidMaxConflictFilesException_base: S.ErrorClass<InvalidMaxConflictFilesException, S.TaggedStruct<"InvalidMaxConflictFilesException", {
+declare const InvalidMaxConflictFilesException_base: S.Class<InvalidMaxConflictFilesException, S.TaggedStruct<"InvalidMaxConflictFilesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMaxConflictFilesException extends InvalidMaxConflictFilesException_base {
 }
-declare const InvalidMaxMergeHunksException_base: S.ErrorClass<InvalidMaxMergeHunksException, S.TaggedStruct<"InvalidMaxMergeHunksException", {
+declare const InvalidMaxMergeHunksException_base: S.Class<InvalidMaxMergeHunksException, S.TaggedStruct<"InvalidMaxMergeHunksException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMaxMergeHunksException extends InvalidMaxMergeHunksException_base {
 }
-declare const InvalidMergeOptionException_base: S.ErrorClass<InvalidMergeOptionException, S.TaggedStruct<"InvalidMergeOptionException", {
+declare const InvalidMergeOptionException_base: S.Class<InvalidMergeOptionException, S.TaggedStruct<"InvalidMergeOptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMergeOptionException extends InvalidMergeOptionException_base {
 }
-declare const MaximumFileContentToLoadExceededException_base: S.ErrorClass<MaximumFileContentToLoadExceededException, S.TaggedStruct<"MaximumFileContentToLoadExceededException", {
+declare const MaximumFileContentToLoadExceededException_base: S.Class<MaximumFileContentToLoadExceededException, S.TaggedStruct<"MaximumFileContentToLoadExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumFileContentToLoadExceededException extends MaximumFileContentToLoadExceededException_base {
 }
-declare const MaximumItemsToCompareExceededException_base: S.ErrorClass<MaximumItemsToCompareExceededException, S.TaggedStruct<"MaximumItemsToCompareExceededException", {
+declare const MaximumItemsToCompareExceededException_base: S.Class<MaximumItemsToCompareExceededException, S.TaggedStruct<"MaximumItemsToCompareExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumItemsToCompareExceededException extends MaximumItemsToCompareExceededException_base {
 }
-declare const MergeOptionRequiredException_base: S.ErrorClass<MergeOptionRequiredException, S.TaggedStruct<"MergeOptionRequiredException", {
+declare const MergeOptionRequiredException_base: S.Class<MergeOptionRequiredException, S.TaggedStruct<"MergeOptionRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MergeOptionRequiredException extends MergeOptionRequiredException_base {
 }
-declare const TipsDivergenceExceededException_base: S.ErrorClass<TipsDivergenceExceededException, S.TaggedStruct<"TipsDivergenceExceededException", {
+declare const TipsDivergenceExceededException_base: S.Class<TipsDivergenceExceededException, S.TaggedStruct<"TipsDivergenceExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TipsDivergenceExceededException extends TipsDivergenceExceededException_base {
 }
-declare const CommitIdsLimitExceededException_base: S.ErrorClass<CommitIdsLimitExceededException, S.TaggedStruct<"CommitIdsLimitExceededException", {
+declare const CommitIdsLimitExceededException_base: S.Class<CommitIdsLimitExceededException, S.TaggedStruct<"CommitIdsLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitIdsLimitExceededException extends CommitIdsLimitExceededException_base {
 }
-declare const CommitIdsListRequiredException_base: S.ErrorClass<CommitIdsListRequiredException, S.TaggedStruct<"CommitIdsListRequiredException", {
+declare const CommitIdsListRequiredException_base: S.Class<CommitIdsListRequiredException, S.TaggedStruct<"CommitIdsListRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitIdsListRequiredException extends CommitIdsListRequiredException_base {
 }
-declare const ApprovalRuleTemplateContentRequiredException_base: S.ErrorClass<ApprovalRuleTemplateContentRequiredException, S.TaggedStruct<"ApprovalRuleTemplateContentRequiredException", {
+declare const ApprovalRuleTemplateContentRequiredException_base: S.Class<ApprovalRuleTemplateContentRequiredException, S.TaggedStruct<"ApprovalRuleTemplateContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleTemplateContentRequiredException extends ApprovalRuleTemplateContentRequiredException_base {
 }
-declare const ApprovalRuleTemplateNameAlreadyExistsException_base: S.ErrorClass<ApprovalRuleTemplateNameAlreadyExistsException, S.TaggedStruct<"ApprovalRuleTemplateNameAlreadyExistsException", {
+declare const ApprovalRuleTemplateNameAlreadyExistsException_base: S.Class<ApprovalRuleTemplateNameAlreadyExistsException, S.TaggedStruct<"ApprovalRuleTemplateNameAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1717,277 +1717,277 @@ declare const ApprovalRuleTemplateNameAlreadyExistsException_base: S.ErrorClass<
 });
 export declare class ApprovalRuleTemplateNameAlreadyExistsException extends ApprovalRuleTemplateNameAlreadyExistsException_base {
 }
-declare const InvalidApprovalRuleTemplateContentException_base: S.ErrorClass<InvalidApprovalRuleTemplateContentException, S.TaggedStruct<"InvalidApprovalRuleTemplateContentException", {
+declare const InvalidApprovalRuleTemplateContentException_base: S.Class<InvalidApprovalRuleTemplateContentException, S.TaggedStruct<"InvalidApprovalRuleTemplateContentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalRuleTemplateContentException extends InvalidApprovalRuleTemplateContentException_base {
 }
-declare const InvalidApprovalRuleTemplateDescriptionException_base: S.ErrorClass<InvalidApprovalRuleTemplateDescriptionException, S.TaggedStruct<"InvalidApprovalRuleTemplateDescriptionException", {
+declare const InvalidApprovalRuleTemplateDescriptionException_base: S.Class<InvalidApprovalRuleTemplateDescriptionException, S.TaggedStruct<"InvalidApprovalRuleTemplateDescriptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalRuleTemplateDescriptionException extends InvalidApprovalRuleTemplateDescriptionException_base {
 }
-declare const NumberOfRuleTemplatesExceededException_base: S.ErrorClass<NumberOfRuleTemplatesExceededException, S.TaggedStruct<"NumberOfRuleTemplatesExceededException", {
+declare const NumberOfRuleTemplatesExceededException_base: S.Class<NumberOfRuleTemplatesExceededException, S.TaggedStruct<"NumberOfRuleTemplatesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NumberOfRuleTemplatesExceededException extends NumberOfRuleTemplatesExceededException_base {
 }
-declare const BranchNameExistsException_base: S.ErrorClass<BranchNameExistsException, S.TaggedStruct<"BranchNameExistsException", {
+declare const BranchNameExistsException_base: S.Class<BranchNameExistsException, S.TaggedStruct<"BranchNameExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BranchNameExistsException extends BranchNameExistsException_base {
 }
-declare const BranchNameRequiredException_base: S.ErrorClass<BranchNameRequiredException, S.TaggedStruct<"BranchNameRequiredException", {
+declare const BranchNameRequiredException_base: S.Class<BranchNameRequiredException, S.TaggedStruct<"BranchNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BranchNameRequiredException extends BranchNameRequiredException_base {
 }
-declare const CommitIdRequiredException_base: S.ErrorClass<CommitIdRequiredException, S.TaggedStruct<"CommitIdRequiredException", {
+declare const CommitIdRequiredException_base: S.Class<CommitIdRequiredException, S.TaggedStruct<"CommitIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitIdRequiredException extends CommitIdRequiredException_base {
 }
-declare const InvalidBranchNameException_base: S.ErrorClass<InvalidBranchNameException, S.TaggedStruct<"InvalidBranchNameException", {
+declare const InvalidBranchNameException_base: S.Class<InvalidBranchNameException, S.TaggedStruct<"InvalidBranchNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBranchNameException extends InvalidBranchNameException_base {
 }
-declare const InvalidCommitIdException_base: S.ErrorClass<InvalidCommitIdException, S.TaggedStruct<"InvalidCommitIdException", {
+declare const InvalidCommitIdException_base: S.Class<InvalidCommitIdException, S.TaggedStruct<"InvalidCommitIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCommitIdException extends InvalidCommitIdException_base {
 }
-declare const BranchDoesNotExistException_base: S.ErrorClass<BranchDoesNotExistException, S.TaggedStruct<"BranchDoesNotExistException", {
+declare const BranchDoesNotExistException_base: S.Class<BranchDoesNotExistException, S.TaggedStruct<"BranchDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BranchDoesNotExistException extends BranchDoesNotExistException_base {
 }
-declare const BranchNameIsTagNameException_base: S.ErrorClass<BranchNameIsTagNameException, S.TaggedStruct<"BranchNameIsTagNameException", {
+declare const BranchNameIsTagNameException_base: S.Class<BranchNameIsTagNameException, S.TaggedStruct<"BranchNameIsTagNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BranchNameIsTagNameException extends BranchNameIsTagNameException_base {
 }
-declare const CommitMessageLengthExceededException_base: S.ErrorClass<CommitMessageLengthExceededException, S.TaggedStruct<"CommitMessageLengthExceededException", {
+declare const CommitMessageLengthExceededException_base: S.Class<CommitMessageLengthExceededException, S.TaggedStruct<"CommitMessageLengthExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitMessageLengthExceededException extends CommitMessageLengthExceededException_base {
 }
-declare const DirectoryNameConflictsWithFileNameException_base: S.ErrorClass<DirectoryNameConflictsWithFileNameException, S.TaggedStruct<"DirectoryNameConflictsWithFileNameException", {
+declare const DirectoryNameConflictsWithFileNameException_base: S.Class<DirectoryNameConflictsWithFileNameException, S.TaggedStruct<"DirectoryNameConflictsWithFileNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DirectoryNameConflictsWithFileNameException extends DirectoryNameConflictsWithFileNameException_base {
 }
-declare const FileContentAndSourceFileSpecifiedException_base: S.ErrorClass<FileContentAndSourceFileSpecifiedException, S.TaggedStruct<"FileContentAndSourceFileSpecifiedException", {
+declare const FileContentAndSourceFileSpecifiedException_base: S.Class<FileContentAndSourceFileSpecifiedException, S.TaggedStruct<"FileContentAndSourceFileSpecifiedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileContentAndSourceFileSpecifiedException extends FileContentAndSourceFileSpecifiedException_base {
 }
-declare const FileContentSizeLimitExceededException_base: S.ErrorClass<FileContentSizeLimitExceededException, S.TaggedStruct<"FileContentSizeLimitExceededException", {
+declare const FileContentSizeLimitExceededException_base: S.Class<FileContentSizeLimitExceededException, S.TaggedStruct<"FileContentSizeLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileContentSizeLimitExceededException extends FileContentSizeLimitExceededException_base {
 }
-declare const FileDoesNotExistException_base: S.ErrorClass<FileDoesNotExistException, S.TaggedStruct<"FileDoesNotExistException", {
+declare const FileDoesNotExistException_base: S.Class<FileDoesNotExistException, S.TaggedStruct<"FileDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileDoesNotExistException extends FileDoesNotExistException_base {
 }
-declare const FileEntryRequiredException_base: S.ErrorClass<FileEntryRequiredException, S.TaggedStruct<"FileEntryRequiredException", {
+declare const FileEntryRequiredException_base: S.Class<FileEntryRequiredException, S.TaggedStruct<"FileEntryRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileEntryRequiredException extends FileEntryRequiredException_base {
 }
-declare const FileModeRequiredException_base: S.ErrorClass<FileModeRequiredException, S.TaggedStruct<"FileModeRequiredException", {
+declare const FileModeRequiredException_base: S.Class<FileModeRequiredException, S.TaggedStruct<"FileModeRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileModeRequiredException extends FileModeRequiredException_base {
 }
-declare const FileNameConflictsWithDirectoryNameException_base: S.ErrorClass<FileNameConflictsWithDirectoryNameException, S.TaggedStruct<"FileNameConflictsWithDirectoryNameException", {
+declare const FileNameConflictsWithDirectoryNameException_base: S.Class<FileNameConflictsWithDirectoryNameException, S.TaggedStruct<"FileNameConflictsWithDirectoryNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileNameConflictsWithDirectoryNameException extends FileNameConflictsWithDirectoryNameException_base {
 }
-declare const FilePathConflictsWithSubmodulePathException_base: S.ErrorClass<FilePathConflictsWithSubmodulePathException, S.TaggedStruct<"FilePathConflictsWithSubmodulePathException", {
+declare const FilePathConflictsWithSubmodulePathException_base: S.Class<FilePathConflictsWithSubmodulePathException, S.TaggedStruct<"FilePathConflictsWithSubmodulePathException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FilePathConflictsWithSubmodulePathException extends FilePathConflictsWithSubmodulePathException_base {
 }
-declare const FolderContentSizeLimitExceededException_base: S.ErrorClass<FolderContentSizeLimitExceededException, S.TaggedStruct<"FolderContentSizeLimitExceededException", {
+declare const FolderContentSizeLimitExceededException_base: S.Class<FolderContentSizeLimitExceededException, S.TaggedStruct<"FolderContentSizeLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FolderContentSizeLimitExceededException extends FolderContentSizeLimitExceededException_base {
 }
-declare const InvalidDeletionParameterException_base: S.ErrorClass<InvalidDeletionParameterException, S.TaggedStruct<"InvalidDeletionParameterException", {
+declare const InvalidDeletionParameterException_base: S.Class<InvalidDeletionParameterException, S.TaggedStruct<"InvalidDeletionParameterException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDeletionParameterException extends InvalidDeletionParameterException_base {
 }
-declare const InvalidEmailException_base: S.ErrorClass<InvalidEmailException, S.TaggedStruct<"InvalidEmailException", {
+declare const InvalidEmailException_base: S.Class<InvalidEmailException, S.TaggedStruct<"InvalidEmailException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidEmailException extends InvalidEmailException_base {
 }
-declare const InvalidFileModeException_base: S.ErrorClass<InvalidFileModeException, S.TaggedStruct<"InvalidFileModeException", {
+declare const InvalidFileModeException_base: S.Class<InvalidFileModeException, S.TaggedStruct<"InvalidFileModeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFileModeException extends InvalidFileModeException_base {
 }
-declare const InvalidParentCommitIdException_base: S.ErrorClass<InvalidParentCommitIdException, S.TaggedStruct<"InvalidParentCommitIdException", {
+declare const InvalidParentCommitIdException_base: S.Class<InvalidParentCommitIdException, S.TaggedStruct<"InvalidParentCommitIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParentCommitIdException extends InvalidParentCommitIdException_base {
 }
-declare const InvalidPathException_base: S.ErrorClass<InvalidPathException, S.TaggedStruct<"InvalidPathException", {
+declare const InvalidPathException_base: S.Class<InvalidPathException, S.TaggedStruct<"InvalidPathException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPathException extends InvalidPathException_base {
 }
-declare const MaximumFileEntriesExceededException_base: S.ErrorClass<MaximumFileEntriesExceededException, S.TaggedStruct<"MaximumFileEntriesExceededException", {
+declare const MaximumFileEntriesExceededException_base: S.Class<MaximumFileEntriesExceededException, S.TaggedStruct<"MaximumFileEntriesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumFileEntriesExceededException extends MaximumFileEntriesExceededException_base {
 }
-declare const NameLengthExceededException_base: S.ErrorClass<NameLengthExceededException, S.TaggedStruct<"NameLengthExceededException", {
+declare const NameLengthExceededException_base: S.Class<NameLengthExceededException, S.TaggedStruct<"NameLengthExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NameLengthExceededException extends NameLengthExceededException_base {
 }
-declare const NoChangeException_base: S.ErrorClass<NoChangeException, S.TaggedStruct<"NoChangeException", {
+declare const NoChangeException_base: S.Class<NoChangeException, S.TaggedStruct<"NoChangeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoChangeException extends NoChangeException_base {
 }
-declare const ParentCommitDoesNotExistException_base: S.ErrorClass<ParentCommitDoesNotExistException, S.TaggedStruct<"ParentCommitDoesNotExistException", {
+declare const ParentCommitDoesNotExistException_base: S.Class<ParentCommitDoesNotExistException, S.TaggedStruct<"ParentCommitDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParentCommitDoesNotExistException extends ParentCommitDoesNotExistException_base {
 }
-declare const ParentCommitIdOutdatedException_base: S.ErrorClass<ParentCommitIdOutdatedException, S.TaggedStruct<"ParentCommitIdOutdatedException", {
+declare const ParentCommitIdOutdatedException_base: S.Class<ParentCommitIdOutdatedException, S.TaggedStruct<"ParentCommitIdOutdatedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParentCommitIdOutdatedException extends ParentCommitIdOutdatedException_base {
 }
-declare const ParentCommitIdRequiredException_base: S.ErrorClass<ParentCommitIdRequiredException, S.TaggedStruct<"ParentCommitIdRequiredException", {
+declare const ParentCommitIdRequiredException_base: S.Class<ParentCommitIdRequiredException, S.TaggedStruct<"ParentCommitIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ParentCommitIdRequiredException extends ParentCommitIdRequiredException_base {
 }
-declare const PathRequiredException_base: S.ErrorClass<PathRequiredException, S.TaggedStruct<"PathRequiredException", {
+declare const PathRequiredException_base: S.Class<PathRequiredException, S.TaggedStruct<"PathRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PathRequiredException extends PathRequiredException_base {
 }
-declare const PutFileEntryConflictException_base: S.ErrorClass<PutFileEntryConflictException, S.TaggedStruct<"PutFileEntryConflictException", {
+declare const PutFileEntryConflictException_base: S.Class<PutFileEntryConflictException, S.TaggedStruct<"PutFileEntryConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PutFileEntryConflictException extends PutFileEntryConflictException_base {
 }
-declare const RestrictedSourceFileException_base: S.ErrorClass<RestrictedSourceFileException, S.TaggedStruct<"RestrictedSourceFileException", {
+declare const RestrictedSourceFileException_base: S.Class<RestrictedSourceFileException, S.TaggedStruct<"RestrictedSourceFileException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RestrictedSourceFileException extends RestrictedSourceFileException_base {
 }
-declare const SamePathRequestException_base: S.ErrorClass<SamePathRequestException, S.TaggedStruct<"SamePathRequestException", {
+declare const SamePathRequestException_base: S.Class<SamePathRequestException, S.TaggedStruct<"SamePathRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SamePathRequestException extends SamePathRequestException_base {
 }
-declare const SourceFileOrContentRequiredException_base: S.ErrorClass<SourceFileOrContentRequiredException, S.TaggedStruct<"SourceFileOrContentRequiredException", {
+declare const SourceFileOrContentRequiredException_base: S.Class<SourceFileOrContentRequiredException, S.TaggedStruct<"SourceFileOrContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SourceFileOrContentRequiredException extends SourceFileOrContentRequiredException_base {
 }
-declare const ClientRequestTokenRequiredException_base: S.ErrorClass<ClientRequestTokenRequiredException, S.TaggedStruct<"ClientRequestTokenRequiredException", {
+declare const ClientRequestTokenRequiredException_base: S.Class<ClientRequestTokenRequiredException, S.TaggedStruct<"ClientRequestTokenRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ClientRequestTokenRequiredException extends ClientRequestTokenRequiredException_base {
 }
-declare const IdempotencyParameterMismatchException_base: S.ErrorClass<IdempotencyParameterMismatchException, S.TaggedStruct<"IdempotencyParameterMismatchException", {
+declare const IdempotencyParameterMismatchException_base: S.Class<IdempotencyParameterMismatchException, S.TaggedStruct<"IdempotencyParameterMismatchException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class IdempotencyParameterMismatchException extends IdempotencyParameterMismatchException_base {
 }
-declare const InvalidClientRequestTokenException_base: S.ErrorClass<InvalidClientRequestTokenException, S.TaggedStruct<"InvalidClientRequestTokenException", {
+declare const InvalidClientRequestTokenException_base: S.Class<InvalidClientRequestTokenException, S.TaggedStruct<"InvalidClientRequestTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidClientRequestTokenException extends InvalidClientRequestTokenException_base {
 }
-declare const InvalidDescriptionException_base: S.ErrorClass<InvalidDescriptionException, S.TaggedStruct<"InvalidDescriptionException", {
+declare const InvalidDescriptionException_base: S.Class<InvalidDescriptionException, S.TaggedStruct<"InvalidDescriptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDescriptionException extends InvalidDescriptionException_base {
 }
-declare const InvalidReferenceNameException_base: S.ErrorClass<InvalidReferenceNameException, S.TaggedStruct<"InvalidReferenceNameException", {
+declare const InvalidReferenceNameException_base: S.Class<InvalidReferenceNameException, S.TaggedStruct<"InvalidReferenceNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidReferenceNameException extends InvalidReferenceNameException_base {
 }
-declare const InvalidTargetException_base: S.ErrorClass<InvalidTargetException, S.TaggedStruct<"InvalidTargetException", {
+declare const InvalidTargetException_base: S.Class<InvalidTargetException, S.TaggedStruct<"InvalidTargetException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetException extends InvalidTargetException_base {
 }
-declare const InvalidTargetsException_base: S.ErrorClass<InvalidTargetsException, S.TaggedStruct<"InvalidTargetsException", {
+declare const InvalidTargetsException_base: S.Class<InvalidTargetsException, S.TaggedStruct<"InvalidTargetsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetsException extends InvalidTargetsException_base {
 }
-declare const InvalidTitleException_base: S.ErrorClass<InvalidTitleException, S.TaggedStruct<"InvalidTitleException", {
+declare const InvalidTitleException_base: S.Class<InvalidTitleException, S.TaggedStruct<"InvalidTitleException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTitleException extends InvalidTitleException_base {
 }
-declare const MaximumOpenPullRequestsExceededException_base: S.ErrorClass<MaximumOpenPullRequestsExceededException, S.TaggedStruct<"MaximumOpenPullRequestsExceededException", {
+declare const MaximumOpenPullRequestsExceededException_base: S.Class<MaximumOpenPullRequestsExceededException, S.TaggedStruct<"MaximumOpenPullRequestsExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumOpenPullRequestsExceededException extends MaximumOpenPullRequestsExceededException_base {
 }
-declare const MultipleRepositoriesInPullRequestException_base: S.ErrorClass<MultipleRepositoriesInPullRequestException, S.TaggedStruct<"MultipleRepositoriesInPullRequestException", {
+declare const MultipleRepositoriesInPullRequestException_base: S.Class<MultipleRepositoriesInPullRequestException, S.TaggedStruct<"MultipleRepositoriesInPullRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MultipleRepositoriesInPullRequestException extends MultipleRepositoriesInPullRequestException_base {
 }
-declare const ReferenceDoesNotExistException_base: S.ErrorClass<ReferenceDoesNotExistException, S.TaggedStruct<"ReferenceDoesNotExistException", {
+declare const ReferenceDoesNotExistException_base: S.Class<ReferenceDoesNotExistException, S.TaggedStruct<"ReferenceDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReferenceDoesNotExistException extends ReferenceDoesNotExistException_base {
 }
-declare const ReferenceNameRequiredException_base: S.ErrorClass<ReferenceNameRequiredException, S.TaggedStruct<"ReferenceNameRequiredException", {
+declare const ReferenceNameRequiredException_base: S.Class<ReferenceNameRequiredException, S.TaggedStruct<"ReferenceNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReferenceNameRequiredException extends ReferenceNameRequiredException_base {
 }
-declare const ReferenceTypeNotSupportedException_base: S.ErrorClass<ReferenceTypeNotSupportedException, S.TaggedStruct<"ReferenceTypeNotSupportedException", {
+declare const ReferenceTypeNotSupportedException_base: S.Class<ReferenceTypeNotSupportedException, S.TaggedStruct<"ReferenceTypeNotSupportedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReferenceTypeNotSupportedException extends ReferenceTypeNotSupportedException_base {
 }
-declare const SourceAndDestinationAreSameException_base: S.ErrorClass<SourceAndDestinationAreSameException, S.TaggedStruct<"SourceAndDestinationAreSameException", {
+declare const SourceAndDestinationAreSameException_base: S.Class<SourceAndDestinationAreSameException, S.TaggedStruct<"SourceAndDestinationAreSameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SourceAndDestinationAreSameException extends SourceAndDestinationAreSameException_base {
 }
-declare const TargetRequiredException_base: S.ErrorClass<TargetRequiredException, S.TaggedStruct<"TargetRequiredException", {
+declare const TargetRequiredException_base: S.Class<TargetRequiredException, S.TaggedStruct<"TargetRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetRequiredException extends TargetRequiredException_base {
 }
-declare const TargetsRequiredException_base: S.ErrorClass<TargetsRequiredException, S.TaggedStruct<"TargetsRequiredException", {
+declare const TargetsRequiredException_base: S.Class<TargetsRequiredException, S.TaggedStruct<"TargetsRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TargetsRequiredException extends TargetsRequiredException_base {
 }
-declare const TitleRequiredException_base: S.ErrorClass<TitleRequiredException, S.TaggedStruct<"TitleRequiredException", {
+declare const TitleRequiredException_base: S.Class<TitleRequiredException, S.TaggedStruct<"TitleRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TitleRequiredException extends TitleRequiredException_base {
 }
-declare const ApprovalRuleContentRequiredException_base: S.ErrorClass<ApprovalRuleContentRequiredException, S.TaggedStruct<"ApprovalRuleContentRequiredException", {
+declare const ApprovalRuleContentRequiredException_base: S.Class<ApprovalRuleContentRequiredException, S.TaggedStruct<"ApprovalRuleContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleContentRequiredException extends ApprovalRuleContentRequiredException_base {
 }
-declare const ApprovalRuleNameAlreadyExistsException_base: S.ErrorClass<ApprovalRuleNameAlreadyExistsException, S.TaggedStruct<"ApprovalRuleNameAlreadyExistsException", {
+declare const ApprovalRuleNameAlreadyExistsException_base: S.Class<ApprovalRuleNameAlreadyExistsException, S.TaggedStruct<"ApprovalRuleNameAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1996,517 +1996,517 @@ declare const ApprovalRuleNameAlreadyExistsException_base: S.ErrorClass<Approval
 });
 export declare class ApprovalRuleNameAlreadyExistsException extends ApprovalRuleNameAlreadyExistsException_base {
 }
-declare const ApprovalRuleNameRequiredException_base: S.ErrorClass<ApprovalRuleNameRequiredException, S.TaggedStruct<"ApprovalRuleNameRequiredException", {
+declare const ApprovalRuleNameRequiredException_base: S.Class<ApprovalRuleNameRequiredException, S.TaggedStruct<"ApprovalRuleNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleNameRequiredException extends ApprovalRuleNameRequiredException_base {
 }
-declare const InvalidApprovalRuleContentException_base: S.ErrorClass<InvalidApprovalRuleContentException, S.TaggedStruct<"InvalidApprovalRuleContentException", {
+declare const InvalidApprovalRuleContentException_base: S.Class<InvalidApprovalRuleContentException, S.TaggedStruct<"InvalidApprovalRuleContentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalRuleContentException extends InvalidApprovalRuleContentException_base {
 }
-declare const InvalidApprovalRuleNameException_base: S.ErrorClass<InvalidApprovalRuleNameException, S.TaggedStruct<"InvalidApprovalRuleNameException", {
+declare const InvalidApprovalRuleNameException_base: S.Class<InvalidApprovalRuleNameException, S.TaggedStruct<"InvalidApprovalRuleNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalRuleNameException extends InvalidApprovalRuleNameException_base {
 }
-declare const InvalidPullRequestIdException_base: S.ErrorClass<InvalidPullRequestIdException, S.TaggedStruct<"InvalidPullRequestIdException", {
+declare const InvalidPullRequestIdException_base: S.Class<InvalidPullRequestIdException, S.TaggedStruct<"InvalidPullRequestIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPullRequestIdException extends InvalidPullRequestIdException_base {
 }
-declare const NumberOfRulesExceededException_base: S.ErrorClass<NumberOfRulesExceededException, S.TaggedStruct<"NumberOfRulesExceededException", {
+declare const NumberOfRulesExceededException_base: S.Class<NumberOfRulesExceededException, S.TaggedStruct<"NumberOfRulesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NumberOfRulesExceededException extends NumberOfRulesExceededException_base {
 }
-declare const PullRequestAlreadyClosedException_base: S.ErrorClass<PullRequestAlreadyClosedException, S.TaggedStruct<"PullRequestAlreadyClosedException", {
+declare const PullRequestAlreadyClosedException_base: S.Class<PullRequestAlreadyClosedException, S.TaggedStruct<"PullRequestAlreadyClosedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestAlreadyClosedException extends PullRequestAlreadyClosedException_base {
 }
-declare const PullRequestDoesNotExistException_base: S.ErrorClass<PullRequestDoesNotExistException, S.TaggedStruct<"PullRequestDoesNotExistException", {
+declare const PullRequestDoesNotExistException_base: S.Class<PullRequestDoesNotExistException, S.TaggedStruct<"PullRequestDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestDoesNotExistException extends PullRequestDoesNotExistException_base {
 }
-declare const PullRequestIdRequiredException_base: S.ErrorClass<PullRequestIdRequiredException, S.TaggedStruct<"PullRequestIdRequiredException", {
+declare const PullRequestIdRequiredException_base: S.Class<PullRequestIdRequiredException, S.TaggedStruct<"PullRequestIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestIdRequiredException extends PullRequestIdRequiredException_base {
 }
-declare const EncryptionKeyInvalidIdException_base: S.ErrorClass<EncryptionKeyInvalidIdException, S.TaggedStruct<"EncryptionKeyInvalidIdException", {
+declare const EncryptionKeyInvalidIdException_base: S.Class<EncryptionKeyInvalidIdException, S.TaggedStruct<"EncryptionKeyInvalidIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyInvalidIdException extends EncryptionKeyInvalidIdException_base {
 }
-declare const EncryptionKeyInvalidUsageException_base: S.ErrorClass<EncryptionKeyInvalidUsageException, S.TaggedStruct<"EncryptionKeyInvalidUsageException", {
+declare const EncryptionKeyInvalidUsageException_base: S.Class<EncryptionKeyInvalidUsageException, S.TaggedStruct<"EncryptionKeyInvalidUsageException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyInvalidUsageException extends EncryptionKeyInvalidUsageException_base {
 }
-declare const InvalidRepositoryDescriptionException_base: S.ErrorClass<InvalidRepositoryDescriptionException, S.TaggedStruct<"InvalidRepositoryDescriptionException", {
+declare const InvalidRepositoryDescriptionException_base: S.Class<InvalidRepositoryDescriptionException, S.TaggedStruct<"InvalidRepositoryDescriptionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryDescriptionException extends InvalidRepositoryDescriptionException_base {
 }
-declare const InvalidSystemTagUsageException_base: S.ErrorClass<InvalidSystemTagUsageException, S.TaggedStruct<"InvalidSystemTagUsageException", {
+declare const InvalidSystemTagUsageException_base: S.Class<InvalidSystemTagUsageException, S.TaggedStruct<"InvalidSystemTagUsageException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSystemTagUsageException extends InvalidSystemTagUsageException_base {
 }
-declare const InvalidTagsMapException_base: S.ErrorClass<InvalidTagsMapException, S.TaggedStruct<"InvalidTagsMapException", {
+declare const InvalidTagsMapException_base: S.Class<InvalidTagsMapException, S.TaggedStruct<"InvalidTagsMapException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagsMapException extends InvalidTagsMapException_base {
 }
-declare const OperationNotAllowedException_base: S.ErrorClass<OperationNotAllowedException, S.TaggedStruct<"OperationNotAllowedException", {
+declare const OperationNotAllowedException_base: S.Class<OperationNotAllowedException, S.TaggedStruct<"OperationNotAllowedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationNotAllowedException extends OperationNotAllowedException_base {
 }
-declare const RepositoryLimitExceededException_base: S.ErrorClass<RepositoryLimitExceededException, S.TaggedStruct<"RepositoryLimitExceededException", {
+declare const RepositoryLimitExceededException_base: S.Class<RepositoryLimitExceededException, S.TaggedStruct<"RepositoryLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryLimitExceededException extends RepositoryLimitExceededException_base {
 }
-declare const RepositoryNameExistsException_base: S.ErrorClass<RepositoryNameExistsException, S.TaggedStruct<"RepositoryNameExistsException", {
+declare const RepositoryNameExistsException_base: S.Class<RepositoryNameExistsException, S.TaggedStruct<"RepositoryNameExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryNameExistsException extends RepositoryNameExistsException_base {
 }
-declare const TagPolicyException_base: S.ErrorClass<TagPolicyException, S.TaggedStruct<"TagPolicyException", {
+declare const TagPolicyException_base: S.Class<TagPolicyException, S.TaggedStruct<"TagPolicyException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagPolicyException extends TagPolicyException_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 ConcurrentReferenceUpdateException_base: S.ErrorClass<ConcurrentReferenceUpdateException, S.TaggedStruct<"ConcurrentReferenceUpdateException", {
+declare const ConcurrentReferenceUpdateException_base: S.Class<ConcurrentReferenceUpdateException, S.TaggedStruct<"ConcurrentReferenceUpdateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConcurrentReferenceUpdateException extends ConcurrentReferenceUpdateException_base {
 }
-declare const InvalidConflictResolutionException_base: S.ErrorClass<InvalidConflictResolutionException, S.TaggedStruct<"InvalidConflictResolutionException", {
+declare const InvalidConflictResolutionException_base: S.Class<InvalidConflictResolutionException, S.TaggedStruct<"InvalidConflictResolutionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidConflictResolutionException extends InvalidConflictResolutionException_base {
 }
-declare const InvalidReplacementContentException_base: S.ErrorClass<InvalidReplacementContentException, S.TaggedStruct<"InvalidReplacementContentException", {
+declare const InvalidReplacementContentException_base: S.Class<InvalidReplacementContentException, S.TaggedStruct<"InvalidReplacementContentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidReplacementContentException extends InvalidReplacementContentException_base {
 }
-declare const InvalidReplacementTypeException_base: S.ErrorClass<InvalidReplacementTypeException, S.TaggedStruct<"InvalidReplacementTypeException", {
+declare const InvalidReplacementTypeException_base: S.Class<InvalidReplacementTypeException, S.TaggedStruct<"InvalidReplacementTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidReplacementTypeException extends InvalidReplacementTypeException_base {
 }
-declare const ManualMergeRequiredException_base: S.ErrorClass<ManualMergeRequiredException, S.TaggedStruct<"ManualMergeRequiredException", {
+declare const ManualMergeRequiredException_base: S.Class<ManualMergeRequiredException, S.TaggedStruct<"ManualMergeRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ManualMergeRequiredException extends ManualMergeRequiredException_base {
 }
-declare const MaximumConflictResolutionEntriesExceededException_base: S.ErrorClass<MaximumConflictResolutionEntriesExceededException, S.TaggedStruct<"MaximumConflictResolutionEntriesExceededException", {
+declare const MaximumConflictResolutionEntriesExceededException_base: S.Class<MaximumConflictResolutionEntriesExceededException, S.TaggedStruct<"MaximumConflictResolutionEntriesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumConflictResolutionEntriesExceededException extends MaximumConflictResolutionEntriesExceededException_base {
 }
-declare const MultipleConflictResolutionEntriesException_base: S.ErrorClass<MultipleConflictResolutionEntriesException, S.TaggedStruct<"MultipleConflictResolutionEntriesException", {
+declare const MultipleConflictResolutionEntriesException_base: S.Class<MultipleConflictResolutionEntriesException, S.TaggedStruct<"MultipleConflictResolutionEntriesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MultipleConflictResolutionEntriesException extends MultipleConflictResolutionEntriesException_base {
 }
-declare const ReplacementContentRequiredException_base: S.ErrorClass<ReplacementContentRequiredException, S.TaggedStruct<"ReplacementContentRequiredException", {
+declare const ReplacementContentRequiredException_base: S.Class<ReplacementContentRequiredException, S.TaggedStruct<"ReplacementContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReplacementContentRequiredException extends ReplacementContentRequiredException_base {
 }
-declare const ReplacementTypeRequiredException_base: S.ErrorClass<ReplacementTypeRequiredException, S.TaggedStruct<"ReplacementTypeRequiredException", {
+declare const ReplacementTypeRequiredException_base: S.Class<ReplacementTypeRequiredException, S.TaggedStruct<"ReplacementTypeRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReplacementTypeRequiredException extends ReplacementTypeRequiredException_base {
 }
-declare const ApprovalRuleTemplateInUseException_base: S.ErrorClass<ApprovalRuleTemplateInUseException, S.TaggedStruct<"ApprovalRuleTemplateInUseException", {
+declare const ApprovalRuleTemplateInUseException_base: S.Class<ApprovalRuleTemplateInUseException, S.TaggedStruct<"ApprovalRuleTemplateInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleTemplateInUseException extends ApprovalRuleTemplateInUseException_base {
 }
-declare const DefaultBranchCannotBeDeletedException_base: S.ErrorClass<DefaultBranchCannotBeDeletedException, S.TaggedStruct<"DefaultBranchCannotBeDeletedException", {
+declare const DefaultBranchCannotBeDeletedException_base: S.Class<DefaultBranchCannotBeDeletedException, S.TaggedStruct<"DefaultBranchCannotBeDeletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DefaultBranchCannotBeDeletedException extends DefaultBranchCannotBeDeletedException_base {
 }
-declare const CommentDeletedException_base: S.ErrorClass<CommentDeletedException, S.TaggedStruct<"CommentDeletedException", {
+declare const CommentDeletedException_base: S.Class<CommentDeletedException, S.TaggedStruct<"CommentDeletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentDeletedException extends CommentDeletedException_base {
 }
-declare const CommentDoesNotExistException_base: S.ErrorClass<CommentDoesNotExistException, S.TaggedStruct<"CommentDoesNotExistException", {
+declare const CommentDoesNotExistException_base: S.Class<CommentDoesNotExistException, S.TaggedStruct<"CommentDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentDoesNotExistException extends CommentDoesNotExistException_base {
 }
-declare const CommentIdRequiredException_base: S.ErrorClass<CommentIdRequiredException, S.TaggedStruct<"CommentIdRequiredException", {
+declare const CommentIdRequiredException_base: S.Class<CommentIdRequiredException, S.TaggedStruct<"CommentIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentIdRequiredException extends CommentIdRequiredException_base {
 }
-declare const InvalidCommentIdException_base: S.ErrorClass<InvalidCommentIdException, S.TaggedStruct<"InvalidCommentIdException", {
+declare const InvalidCommentIdException_base: S.Class<InvalidCommentIdException, S.TaggedStruct<"InvalidCommentIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCommentIdException extends InvalidCommentIdException_base {
 }
-declare const CannotDeleteApprovalRuleFromTemplateException_base: S.ErrorClass<CannotDeleteApprovalRuleFromTemplateException, S.TaggedStruct<"CannotDeleteApprovalRuleFromTemplateException", {
+declare const CannotDeleteApprovalRuleFromTemplateException_base: S.Class<CannotDeleteApprovalRuleFromTemplateException, S.TaggedStruct<"CannotDeleteApprovalRuleFromTemplateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CannotDeleteApprovalRuleFromTemplateException extends CannotDeleteApprovalRuleFromTemplateException_base {
 }
-declare const ActorDoesNotExistException_base: S.ErrorClass<ActorDoesNotExistException, S.TaggedStruct<"ActorDoesNotExistException", {
+declare const ActorDoesNotExistException_base: S.Class<ActorDoesNotExistException, S.TaggedStruct<"ActorDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActorDoesNotExistException extends ActorDoesNotExistException_base {
 }
-declare const InvalidActorArnException_base: S.ErrorClass<InvalidActorArnException, S.TaggedStruct<"InvalidActorArnException", {
+declare const InvalidActorArnException_base: S.Class<InvalidActorArnException, S.TaggedStruct<"InvalidActorArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidActorArnException extends InvalidActorArnException_base {
 }
-declare const InvalidMaxResultsException_base: S.ErrorClass<InvalidMaxResultsException, S.TaggedStruct<"InvalidMaxResultsException", {
+declare const InvalidMaxResultsException_base: S.Class<InvalidMaxResultsException, S.TaggedStruct<"InvalidMaxResultsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMaxResultsException extends InvalidMaxResultsException_base {
 }
-declare const InvalidPullRequestEventTypeException_base: S.ErrorClass<InvalidPullRequestEventTypeException, S.TaggedStruct<"InvalidPullRequestEventTypeException", {
+declare const InvalidPullRequestEventTypeException_base: S.Class<InvalidPullRequestEventTypeException, S.TaggedStruct<"InvalidPullRequestEventTypeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPullRequestEventTypeException extends InvalidPullRequestEventTypeException_base {
 }
-declare const InvalidRevisionIdException_base: S.ErrorClass<InvalidRevisionIdException, S.TaggedStruct<"InvalidRevisionIdException", {
+declare const InvalidRevisionIdException_base: S.Class<InvalidRevisionIdException, S.TaggedStruct<"InvalidRevisionIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRevisionIdException extends InvalidRevisionIdException_base {
 }
-declare const RevisionIdRequiredException_base: S.ErrorClass<RevisionIdRequiredException, S.TaggedStruct<"RevisionIdRequiredException", {
+declare const RevisionIdRequiredException_base: S.Class<RevisionIdRequiredException, S.TaggedStruct<"RevisionIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RevisionIdRequiredException extends RevisionIdRequiredException_base {
 }
-declare const RevisionNotCurrentException_base: S.ErrorClass<RevisionNotCurrentException, S.TaggedStruct<"RevisionNotCurrentException", {
+declare const RevisionNotCurrentException_base: S.Class<RevisionNotCurrentException, S.TaggedStruct<"RevisionNotCurrentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RevisionNotCurrentException extends RevisionNotCurrentException_base {
 }
-declare const BlobIdDoesNotExistException_base: S.ErrorClass<BlobIdDoesNotExistException, S.TaggedStruct<"BlobIdDoesNotExistException", {
+declare const BlobIdDoesNotExistException_base: S.Class<BlobIdDoesNotExistException, S.TaggedStruct<"BlobIdDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BlobIdDoesNotExistException extends BlobIdDoesNotExistException_base {
 }
-declare const BlobIdRequiredException_base: S.ErrorClass<BlobIdRequiredException, S.TaggedStruct<"BlobIdRequiredException", {
+declare const BlobIdRequiredException_base: S.Class<BlobIdRequiredException, S.TaggedStruct<"BlobIdRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BlobIdRequiredException extends BlobIdRequiredException_base {
 }
-declare const FileTooLargeException_base: S.ErrorClass<FileTooLargeException, S.TaggedStruct<"FileTooLargeException", {
+declare const FileTooLargeException_base: S.Class<FileTooLargeException, S.TaggedStruct<"FileTooLargeException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileTooLargeException extends FileTooLargeException_base {
 }
-declare const InvalidBlobIdException_base: S.ErrorClass<InvalidBlobIdException, S.TaggedStruct<"InvalidBlobIdException", {
+declare const InvalidBlobIdException_base: S.Class<InvalidBlobIdException, S.TaggedStruct<"InvalidBlobIdException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBlobIdException extends InvalidBlobIdException_base {
 }
-declare const InvalidReactionUserArnException_base: S.ErrorClass<InvalidReactionUserArnException, S.TaggedStruct<"InvalidReactionUserArnException", {
+declare const InvalidReactionUserArnException_base: S.Class<InvalidReactionUserArnException, S.TaggedStruct<"InvalidReactionUserArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidReactionUserArnException extends InvalidReactionUserArnException_base {
 }
-declare const RepositoryNotAssociatedWithPullRequestException_base: S.ErrorClass<RepositoryNotAssociatedWithPullRequestException, S.TaggedStruct<"RepositoryNotAssociatedWithPullRequestException", {
+declare const RepositoryNotAssociatedWithPullRequestException_base: S.Class<RepositoryNotAssociatedWithPullRequestException, S.TaggedStruct<"RepositoryNotAssociatedWithPullRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryNotAssociatedWithPullRequestException extends RepositoryNotAssociatedWithPullRequestException_base {
 }
-declare const CommitIdDoesNotExistException_base: S.ErrorClass<CommitIdDoesNotExistException, S.TaggedStruct<"CommitIdDoesNotExistException", {
+declare const CommitIdDoesNotExistException_base: S.Class<CommitIdDoesNotExistException, S.TaggedStruct<"CommitIdDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommitIdDoesNotExistException extends CommitIdDoesNotExistException_base {
 }
-declare const PathDoesNotExistException_base: S.ErrorClass<PathDoesNotExistException, S.TaggedStruct<"PathDoesNotExistException", {
+declare const PathDoesNotExistException_base: S.Class<PathDoesNotExistException, S.TaggedStruct<"PathDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PathDoesNotExistException extends PathDoesNotExistException_base {
 }
-declare const FolderDoesNotExistException_base: S.ErrorClass<FolderDoesNotExistException, S.TaggedStruct<"FolderDoesNotExistException", {
+declare const FolderDoesNotExistException_base: S.Class<FolderDoesNotExistException, S.TaggedStruct<"FolderDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FolderDoesNotExistException extends FolderDoesNotExistException_base {
 }
-declare const InvalidDestinationCommitSpecifierException_base: S.ErrorClass<InvalidDestinationCommitSpecifierException, S.TaggedStruct<"InvalidDestinationCommitSpecifierException", {
+declare const InvalidDestinationCommitSpecifierException_base: S.Class<InvalidDestinationCommitSpecifierException, S.TaggedStruct<"InvalidDestinationCommitSpecifierException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidDestinationCommitSpecifierException extends InvalidDestinationCommitSpecifierException_base {
 }
-declare const InvalidSourceCommitSpecifierException_base: S.ErrorClass<InvalidSourceCommitSpecifierException, S.TaggedStruct<"InvalidSourceCommitSpecifierException", {
+declare const InvalidSourceCommitSpecifierException_base: S.Class<InvalidSourceCommitSpecifierException, S.TaggedStruct<"InvalidSourceCommitSpecifierException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSourceCommitSpecifierException extends InvalidSourceCommitSpecifierException_base {
 }
-declare const AuthorDoesNotExistException_base: S.ErrorClass<AuthorDoesNotExistException, S.TaggedStruct<"AuthorDoesNotExistException", {
+declare const AuthorDoesNotExistException_base: S.Class<AuthorDoesNotExistException, S.TaggedStruct<"AuthorDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AuthorDoesNotExistException extends AuthorDoesNotExistException_base {
 }
-declare const InvalidAuthorArnException_base: S.ErrorClass<InvalidAuthorArnException, S.TaggedStruct<"InvalidAuthorArnException", {
+declare const InvalidAuthorArnException_base: S.Class<InvalidAuthorArnException, S.TaggedStruct<"InvalidAuthorArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAuthorArnException extends InvalidAuthorArnException_base {
 }
-declare const InvalidPullRequestStatusException_base: S.ErrorClass<InvalidPullRequestStatusException, S.TaggedStruct<"InvalidPullRequestStatusException", {
+declare const InvalidPullRequestStatusException_base: S.Class<InvalidPullRequestStatusException, S.TaggedStruct<"InvalidPullRequestStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPullRequestStatusException extends InvalidPullRequestStatusException_base {
 }
-declare const InvalidOrderException_base: S.ErrorClass<InvalidOrderException, S.TaggedStruct<"InvalidOrderException", {
+declare const InvalidOrderException_base: S.Class<InvalidOrderException, S.TaggedStruct<"InvalidOrderException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOrderException extends InvalidOrderException_base {
 }
-declare const InvalidSortByException_base: S.ErrorClass<InvalidSortByException, S.TaggedStruct<"InvalidSortByException", {
+declare const InvalidSortByException_base: S.Class<InvalidSortByException, S.TaggedStruct<"InvalidSortByException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSortByException extends InvalidSortByException_base {
 }
-declare const InvalidResourceArnException_base: S.ErrorClass<InvalidResourceArnException, S.TaggedStruct<"InvalidResourceArnException", {
+declare const InvalidResourceArnException_base: S.Class<InvalidResourceArnException, S.TaggedStruct<"InvalidResourceArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceArnException extends InvalidResourceArnException_base {
 }
-declare const ResourceArnRequiredException_base: S.ErrorClass<ResourceArnRequiredException, S.TaggedStruct<"ResourceArnRequiredException", {
+declare const ResourceArnRequiredException_base: S.Class<ResourceArnRequiredException, S.TaggedStruct<"ResourceArnRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceArnRequiredException extends ResourceArnRequiredException_base {
 }
-declare const InvalidTargetBranchException_base: S.ErrorClass<InvalidTargetBranchException, S.TaggedStruct<"InvalidTargetBranchException", {
+declare const InvalidTargetBranchException_base: S.Class<InvalidTargetBranchException, S.TaggedStruct<"InvalidTargetBranchException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTargetBranchException extends InvalidTargetBranchException_base {
 }
-declare const PullRequestApprovalRulesNotSatisfiedException_base: S.ErrorClass<PullRequestApprovalRulesNotSatisfiedException, S.TaggedStruct<"PullRequestApprovalRulesNotSatisfiedException", {
+declare const PullRequestApprovalRulesNotSatisfiedException_base: S.Class<PullRequestApprovalRulesNotSatisfiedException, S.TaggedStruct<"PullRequestApprovalRulesNotSatisfiedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestApprovalRulesNotSatisfiedException extends PullRequestApprovalRulesNotSatisfiedException_base {
 }
-declare const TipOfSourceReferenceIsDifferentException_base: S.ErrorClass<TipOfSourceReferenceIsDifferentException, S.TaggedStruct<"TipOfSourceReferenceIsDifferentException", {
+declare const TipOfSourceReferenceIsDifferentException_base: S.Class<TipOfSourceReferenceIsDifferentException, S.TaggedStruct<"TipOfSourceReferenceIsDifferentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TipOfSourceReferenceIsDifferentException extends TipOfSourceReferenceIsDifferentException_base {
 }
-declare const InvalidOverrideStatusException_base: S.ErrorClass<InvalidOverrideStatusException, S.TaggedStruct<"InvalidOverrideStatusException", {
+declare const InvalidOverrideStatusException_base: S.Class<InvalidOverrideStatusException, S.TaggedStruct<"InvalidOverrideStatusException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidOverrideStatusException extends InvalidOverrideStatusException_base {
 }
-declare const OverrideAlreadySetException_base: S.ErrorClass<OverrideAlreadySetException, S.TaggedStruct<"OverrideAlreadySetException", {
+declare const OverrideAlreadySetException_base: S.Class<OverrideAlreadySetException, S.TaggedStruct<"OverrideAlreadySetException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OverrideAlreadySetException extends OverrideAlreadySetException_base {
 }
-declare const OverrideStatusRequiredException_base: S.ErrorClass<OverrideStatusRequiredException, S.TaggedStruct<"OverrideStatusRequiredException", {
+declare const OverrideStatusRequiredException_base: S.Class<OverrideStatusRequiredException, S.TaggedStruct<"OverrideStatusRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OverrideStatusRequiredException extends OverrideStatusRequiredException_base {
 }
-declare const BeforeCommitIdAndAfterCommitIdAreSameException_base: S.ErrorClass<BeforeCommitIdAndAfterCommitIdAreSameException, S.TaggedStruct<"BeforeCommitIdAndAfterCommitIdAreSameException", {
+declare const BeforeCommitIdAndAfterCommitIdAreSameException_base: S.Class<BeforeCommitIdAndAfterCommitIdAreSameException, S.TaggedStruct<"BeforeCommitIdAndAfterCommitIdAreSameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class BeforeCommitIdAndAfterCommitIdAreSameException extends BeforeCommitIdAndAfterCommitIdAreSameException_base {
 }
-declare const CommentContentRequiredException_base: S.ErrorClass<CommentContentRequiredException, S.TaggedStruct<"CommentContentRequiredException", {
+declare const CommentContentRequiredException_base: S.Class<CommentContentRequiredException, S.TaggedStruct<"CommentContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentContentRequiredException extends CommentContentRequiredException_base {
 }
-declare const CommentContentSizeLimitExceededException_base: S.ErrorClass<CommentContentSizeLimitExceededException, S.TaggedStruct<"CommentContentSizeLimitExceededException", {
+declare const CommentContentSizeLimitExceededException_base: S.Class<CommentContentSizeLimitExceededException, S.TaggedStruct<"CommentContentSizeLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentContentSizeLimitExceededException extends CommentContentSizeLimitExceededException_base {
 }
-declare const InvalidFileLocationException_base: S.ErrorClass<InvalidFileLocationException, S.TaggedStruct<"InvalidFileLocationException", {
+declare const InvalidFileLocationException_base: S.Class<InvalidFileLocationException, S.TaggedStruct<"InvalidFileLocationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFileLocationException extends InvalidFileLocationException_base {
 }
-declare const InvalidFilePositionException_base: S.ErrorClass<InvalidFilePositionException, S.TaggedStruct<"InvalidFilePositionException", {
+declare const InvalidFilePositionException_base: S.Class<InvalidFilePositionException, S.TaggedStruct<"InvalidFilePositionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidFilePositionException extends InvalidFilePositionException_base {
 }
-declare const InvalidRelativeFileVersionEnumException_base: S.ErrorClass<InvalidRelativeFileVersionEnumException, S.TaggedStruct<"InvalidRelativeFileVersionEnumException", {
+declare const InvalidRelativeFileVersionEnumException_base: S.Class<InvalidRelativeFileVersionEnumException, S.TaggedStruct<"InvalidRelativeFileVersionEnumException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRelativeFileVersionEnumException extends InvalidRelativeFileVersionEnumException_base {
 }
-declare const InvalidReactionValueException_base: S.ErrorClass<InvalidReactionValueException, S.TaggedStruct<"InvalidReactionValueException", {
+declare const InvalidReactionValueException_base: S.Class<InvalidReactionValueException, S.TaggedStruct<"InvalidReactionValueException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidReactionValueException extends InvalidReactionValueException_base {
 }
-declare const ReactionLimitExceededException_base: S.ErrorClass<ReactionLimitExceededException, S.TaggedStruct<"ReactionLimitExceededException", {
+declare const ReactionLimitExceededException_base: S.Class<ReactionLimitExceededException, S.TaggedStruct<"ReactionLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReactionLimitExceededException extends ReactionLimitExceededException_base {
 }
-declare const ReactionValueRequiredException_base: S.ErrorClass<ReactionValueRequiredException, S.TaggedStruct<"ReactionValueRequiredException", {
+declare const ReactionValueRequiredException_base: S.Class<ReactionValueRequiredException, S.TaggedStruct<"ReactionValueRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ReactionValueRequiredException extends ReactionValueRequiredException_base {
 }
-declare const FileContentRequiredException_base: S.ErrorClass<FileContentRequiredException, S.TaggedStruct<"FileContentRequiredException", {
+declare const FileContentRequiredException_base: S.Class<FileContentRequiredException, S.TaggedStruct<"FileContentRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class FileContentRequiredException extends FileContentRequiredException_base {
 }
-declare const SameFileContentException_base: S.ErrorClass<SameFileContentException, S.TaggedStruct<"SameFileContentException", {
+declare const SameFileContentException_base: S.Class<SameFileContentException, S.TaggedStruct<"SameFileContentException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class SameFileContentException extends SameFileContentException_base {
 }
-declare const InvalidRepositoryTriggerBranchNameException_base: S.ErrorClass<InvalidRepositoryTriggerBranchNameException, S.TaggedStruct<"InvalidRepositoryTriggerBranchNameException", {
+declare const InvalidRepositoryTriggerBranchNameException_base: S.Class<InvalidRepositoryTriggerBranchNameException, S.TaggedStruct<"InvalidRepositoryTriggerBranchNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerBranchNameException extends InvalidRepositoryTriggerBranchNameException_base {
 }
-declare const InvalidRepositoryTriggerCustomDataException_base: S.ErrorClass<InvalidRepositoryTriggerCustomDataException, S.TaggedStruct<"InvalidRepositoryTriggerCustomDataException", {
+declare const InvalidRepositoryTriggerCustomDataException_base: S.Class<InvalidRepositoryTriggerCustomDataException, S.TaggedStruct<"InvalidRepositoryTriggerCustomDataException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerCustomDataException extends InvalidRepositoryTriggerCustomDataException_base {
 }
-declare const InvalidRepositoryTriggerDestinationArnException_base: S.ErrorClass<InvalidRepositoryTriggerDestinationArnException, S.TaggedStruct<"InvalidRepositoryTriggerDestinationArnException", {
+declare const InvalidRepositoryTriggerDestinationArnException_base: S.Class<InvalidRepositoryTriggerDestinationArnException, S.TaggedStruct<"InvalidRepositoryTriggerDestinationArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerDestinationArnException extends InvalidRepositoryTriggerDestinationArnException_base {
 }
-declare const InvalidRepositoryTriggerEventsException_base: S.ErrorClass<InvalidRepositoryTriggerEventsException, S.TaggedStruct<"InvalidRepositoryTriggerEventsException", {
+declare const InvalidRepositoryTriggerEventsException_base: S.Class<InvalidRepositoryTriggerEventsException, S.TaggedStruct<"InvalidRepositoryTriggerEventsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerEventsException extends InvalidRepositoryTriggerEventsException_base {
 }
-declare const InvalidRepositoryTriggerNameException_base: S.ErrorClass<InvalidRepositoryTriggerNameException, S.TaggedStruct<"InvalidRepositoryTriggerNameException", {
+declare const InvalidRepositoryTriggerNameException_base: S.Class<InvalidRepositoryTriggerNameException, S.TaggedStruct<"InvalidRepositoryTriggerNameException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerNameException extends InvalidRepositoryTriggerNameException_base {
 }
-declare const InvalidRepositoryTriggerRegionException_base: S.ErrorClass<InvalidRepositoryTriggerRegionException, S.TaggedStruct<"InvalidRepositoryTriggerRegionException", {
+declare const InvalidRepositoryTriggerRegionException_base: S.Class<InvalidRepositoryTriggerRegionException, S.TaggedStruct<"InvalidRepositoryTriggerRegionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRepositoryTriggerRegionException extends InvalidRepositoryTriggerRegionException_base {
 }
-declare const MaximumBranchesExceededException_base: S.ErrorClass<MaximumBranchesExceededException, S.TaggedStruct<"MaximumBranchesExceededException", {
+declare const MaximumBranchesExceededException_base: S.Class<MaximumBranchesExceededException, S.TaggedStruct<"MaximumBranchesExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumBranchesExceededException extends MaximumBranchesExceededException_base {
 }
-declare const MaximumRepositoryTriggersExceededException_base: S.ErrorClass<MaximumRepositoryTriggersExceededException, S.TaggedStruct<"MaximumRepositoryTriggersExceededException", {
+declare const MaximumRepositoryTriggersExceededException_base: S.Class<MaximumRepositoryTriggersExceededException, S.TaggedStruct<"MaximumRepositoryTriggersExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumRepositoryTriggersExceededException extends MaximumRepositoryTriggersExceededException_base {
 }
-declare const RepositoryTriggerBranchNameListRequiredException_base: S.ErrorClass<RepositoryTriggerBranchNameListRequiredException, S.TaggedStruct<"RepositoryTriggerBranchNameListRequiredException", {
+declare const RepositoryTriggerBranchNameListRequiredException_base: S.Class<RepositoryTriggerBranchNameListRequiredException, S.TaggedStruct<"RepositoryTriggerBranchNameListRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryTriggerBranchNameListRequiredException extends RepositoryTriggerBranchNameListRequiredException_base {
 }
-declare const RepositoryTriggerDestinationArnRequiredException_base: S.ErrorClass<RepositoryTriggerDestinationArnRequiredException, S.TaggedStruct<"RepositoryTriggerDestinationArnRequiredException", {
+declare const RepositoryTriggerDestinationArnRequiredException_base: S.Class<RepositoryTriggerDestinationArnRequiredException, S.TaggedStruct<"RepositoryTriggerDestinationArnRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryTriggerDestinationArnRequiredException extends RepositoryTriggerDestinationArnRequiredException_base {
 }
-declare const RepositoryTriggerEventsListRequiredException_base: S.ErrorClass<RepositoryTriggerEventsListRequiredException, S.TaggedStruct<"RepositoryTriggerEventsListRequiredException", {
+declare const RepositoryTriggerEventsListRequiredException_base: S.Class<RepositoryTriggerEventsListRequiredException, S.TaggedStruct<"RepositoryTriggerEventsListRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryTriggerEventsListRequiredException extends RepositoryTriggerEventsListRequiredException_base {
 }
-declare const RepositoryTriggerNameRequiredException_base: S.ErrorClass<RepositoryTriggerNameRequiredException, S.TaggedStruct<"RepositoryTriggerNameRequiredException", {
+declare const RepositoryTriggerNameRequiredException_base: S.Class<RepositoryTriggerNameRequiredException, S.TaggedStruct<"RepositoryTriggerNameRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryTriggerNameRequiredException extends RepositoryTriggerNameRequiredException_base {
 }
-declare const RepositoryTriggersListRequiredException_base: S.ErrorClass<RepositoryTriggersListRequiredException, S.TaggedStruct<"RepositoryTriggersListRequiredException", {
+declare const RepositoryTriggersListRequiredException_base: S.Class<RepositoryTriggersListRequiredException, S.TaggedStruct<"RepositoryTriggersListRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryTriggersListRequiredException extends RepositoryTriggersListRequiredException_base {
 }
-declare const TagsMapRequiredException_base: S.ErrorClass<TagsMapRequiredException, S.TaggedStruct<"TagsMapRequiredException", {
+declare const TagsMapRequiredException_base: S.Class<TagsMapRequiredException, S.TaggedStruct<"TagsMapRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagsMapRequiredException extends TagsMapRequiredException_base {
 }
-declare const InvalidTagKeysListException_base: S.ErrorClass<InvalidTagKeysListException, S.TaggedStruct<"InvalidTagKeysListException", {
+declare const InvalidTagKeysListException_base: S.Class<InvalidTagKeysListException, S.TaggedStruct<"InvalidTagKeysListException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagKeysListException extends InvalidTagKeysListException_base {
 }
-declare const TagKeysListRequiredException_base: S.ErrorClass<TagKeysListRequiredException, S.TaggedStruct<"TagKeysListRequiredException", {
+declare const TagKeysListRequiredException_base: S.Class<TagKeysListRequiredException, S.TaggedStruct<"TagKeysListRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TagKeysListRequiredException extends TagKeysListRequiredException_base {
 }
-declare const InvalidRuleContentSha256Exception_base: S.ErrorClass<InvalidRuleContentSha256Exception, S.TaggedStruct<"InvalidRuleContentSha256Exception", {
+declare const InvalidRuleContentSha256Exception_base: S.Class<InvalidRuleContentSha256Exception, S.TaggedStruct<"InvalidRuleContentSha256Exception", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRuleContentSha256Exception extends InvalidRuleContentSha256Exception_base {
 }
-declare const CommentNotCreatedByCallerException_base: S.ErrorClass<CommentNotCreatedByCallerException, S.TaggedStruct<"CommentNotCreatedByCallerException", {
+declare const CommentNotCreatedByCallerException_base: S.Class<CommentNotCreatedByCallerException, S.TaggedStruct<"CommentNotCreatedByCallerException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CommentNotCreatedByCallerException extends CommentNotCreatedByCallerException_base {
 }
-declare const ApprovalRuleDoesNotExistException_base: S.ErrorClass<ApprovalRuleDoesNotExistException, S.TaggedStruct<"ApprovalRuleDoesNotExistException", {
+declare const ApprovalRuleDoesNotExistException_base: S.Class<ApprovalRuleDoesNotExistException, S.TaggedStruct<"ApprovalRuleDoesNotExistException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalRuleDoesNotExistException extends ApprovalRuleDoesNotExistException_base {
 }
-declare const CannotModifyApprovalRuleFromTemplateException_base: S.ErrorClass<CannotModifyApprovalRuleFromTemplateException, S.TaggedStruct<"CannotModifyApprovalRuleFromTemplateException", {
+declare const CannotModifyApprovalRuleFromTemplateException_base: S.Class<CannotModifyApprovalRuleFromTemplateException, S.TaggedStruct<"CannotModifyApprovalRuleFromTemplateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class CannotModifyApprovalRuleFromTemplateException extends CannotModifyApprovalRuleFromTemplateException_base {
 }
-declare const ApprovalStateRequiredException_base: S.ErrorClass<ApprovalStateRequiredException, S.TaggedStruct<"ApprovalStateRequiredException", {
+declare const ApprovalStateRequiredException_base: S.Class<ApprovalStateRequiredException, S.TaggedStruct<"ApprovalStateRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalStateRequiredException extends ApprovalStateRequiredException_base {
 }
-declare const InvalidApprovalStateException_base: S.ErrorClass<InvalidApprovalStateException, S.TaggedStruct<"InvalidApprovalStateException", {
+declare const InvalidApprovalStateException_base: S.Class<InvalidApprovalStateException, S.TaggedStruct<"InvalidApprovalStateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalStateException extends InvalidApprovalStateException_base {
 }
-declare const MaximumNumberOfApprovalsExceededException_base: S.ErrorClass<MaximumNumberOfApprovalsExceededException, S.TaggedStruct<"MaximumNumberOfApprovalsExceededException", {
+declare const MaximumNumberOfApprovalsExceededException_base: S.Class<MaximumNumberOfApprovalsExceededException, S.TaggedStruct<"MaximumNumberOfApprovalsExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumNumberOfApprovalsExceededException extends MaximumNumberOfApprovalsExceededException_base {
 }
-declare const PullRequestCannotBeApprovedByAuthorException_base: S.ErrorClass<PullRequestCannotBeApprovedByAuthorException, S.TaggedStruct<"PullRequestCannotBeApprovedByAuthorException", {
+declare const PullRequestCannotBeApprovedByAuthorException_base: S.Class<PullRequestCannotBeApprovedByAuthorException, S.TaggedStruct<"PullRequestCannotBeApprovedByAuthorException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestCannotBeApprovedByAuthorException extends PullRequestCannotBeApprovedByAuthorException_base {
 }
-declare const InvalidPullRequestStatusUpdateException_base: S.ErrorClass<InvalidPullRequestStatusUpdateException, S.TaggedStruct<"InvalidPullRequestStatusUpdateException", {
+declare const InvalidPullRequestStatusUpdateException_base: S.Class<InvalidPullRequestStatusUpdateException, S.TaggedStruct<"InvalidPullRequestStatusUpdateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidPullRequestStatusUpdateException extends InvalidPullRequestStatusUpdateException_base {
 }
-declare const PullRequestStatusRequiredException_base: S.ErrorClass<PullRequestStatusRequiredException, S.TaggedStruct<"PullRequestStatusRequiredException", {
+declare const PullRequestStatusRequiredException_base: S.Class<PullRequestStatusRequiredException, S.TaggedStruct<"PullRequestStatusRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PullRequestStatusRequiredException extends PullRequestStatusRequiredException_base {
 }
-declare const EncryptionKeyRequiredException_base: S.ErrorClass<EncryptionKeyRequiredException, S.TaggedStruct<"EncryptionKeyRequiredException", {
+declare const EncryptionKeyRequiredException_base: S.Class<EncryptionKeyRequiredException, S.TaggedStruct<"EncryptionKeyRequiredException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class EncryptionKeyRequiredException extends EncryptionKeyRequiredException_base {