@aws-sdk/client-codecommit 3.933.0 → 3.935.0

package/dist-es/models/errors.js

@@ -0,0 +1,2269 @@
+import { CodeCommitServiceException as __BaseException } from "./CodeCommitServiceException";
+export class ActorDoesNotExistException extends __BaseException {
+    name = "ActorDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActorDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActorDoesNotExistException.prototype);
+    }
+}
+export class ApprovalRuleContentRequiredException extends __BaseException {
+    name = "ApprovalRuleContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleContentRequiredException.prototype);
+    }
+}
+export class ApprovalRuleDoesNotExistException extends __BaseException {
+    name = "ApprovalRuleDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleDoesNotExistException.prototype);
+    }
+}
+export class ApprovalRuleNameAlreadyExistsException extends __BaseException {
+    name = "ApprovalRuleNameAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleNameAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleNameAlreadyExistsException.prototype);
+    }
+}
+export class ApprovalRuleNameRequiredException extends __BaseException {
+    name = "ApprovalRuleNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleNameRequiredException.prototype);
+    }
+}
+export class ApprovalRuleTemplateContentRequiredException extends __BaseException {
+    name = "ApprovalRuleTemplateContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleTemplateContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleTemplateContentRequiredException.prototype);
+    }
+}
+export class ApprovalRuleTemplateDoesNotExistException extends __BaseException {
+    name = "ApprovalRuleTemplateDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleTemplateDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleTemplateDoesNotExistException.prototype);
+    }
+}
+export class ApprovalRuleTemplateInUseException extends __BaseException {
+    name = "ApprovalRuleTemplateInUseException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleTemplateInUseException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleTemplateInUseException.prototype);
+    }
+}
+export class ApprovalRuleTemplateNameAlreadyExistsException extends __BaseException {
+    name = "ApprovalRuleTemplateNameAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleTemplateNameAlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleTemplateNameAlreadyExistsException.prototype);
+    }
+}
+export class ApprovalRuleTemplateNameRequiredException extends __BaseException {
+    name = "ApprovalRuleTemplateNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalRuleTemplateNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalRuleTemplateNameRequiredException.prototype);
+    }
+}
+export class ApprovalStateRequiredException extends __BaseException {
+    name = "ApprovalStateRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ApprovalStateRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ApprovalStateRequiredException.prototype);
+    }
+}
+export class EncryptionIntegrityChecksFailedException extends __BaseException {
+    name = "EncryptionIntegrityChecksFailedException";
+    $fault = "server";
+    constructor(opts) {
+        super({
+            name: "EncryptionIntegrityChecksFailedException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionIntegrityChecksFailedException.prototype);
+    }
+}
+export class EncryptionKeyAccessDeniedException extends __BaseException {
+    name = "EncryptionKeyAccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyAccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyAccessDeniedException.prototype);
+    }
+}
+export class EncryptionKeyDisabledException extends __BaseException {
+    name = "EncryptionKeyDisabledException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyDisabledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyDisabledException.prototype);
+    }
+}
+export class EncryptionKeyNotFoundException extends __BaseException {
+    name = "EncryptionKeyNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyNotFoundException.prototype);
+    }
+}
+export class EncryptionKeyUnavailableException extends __BaseException {
+    name = "EncryptionKeyUnavailableException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyUnavailableException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyUnavailableException.prototype);
+    }
+}
+export class InvalidApprovalRuleTemplateNameException extends __BaseException {
+    name = "InvalidApprovalRuleTemplateNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalRuleTemplateNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalRuleTemplateNameException.prototype);
+    }
+}
+export class InvalidRepositoryNameException extends __BaseException {
+    name = "InvalidRepositoryNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryNameException.prototype);
+    }
+}
+export class MaximumRuleTemplatesAssociatedWithRepositoryException extends __BaseException {
+    name = "MaximumRuleTemplatesAssociatedWithRepositoryException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumRuleTemplatesAssociatedWithRepositoryException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumRuleTemplatesAssociatedWithRepositoryException.prototype);
+    }
+}
+export class RepositoryDoesNotExistException extends __BaseException {
+    name = "RepositoryDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryDoesNotExistException.prototype);
+    }
+}
+export class RepositoryNameRequiredException extends __BaseException {
+    name = "RepositoryNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNameRequiredException.prototype);
+    }
+}
+export class AuthorDoesNotExistException extends __BaseException {
+    name = "AuthorDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "AuthorDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AuthorDoesNotExistException.prototype);
+    }
+}
+export class MaximumRepositoryNamesExceededException extends __BaseException {
+    name = "MaximumRepositoryNamesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumRepositoryNamesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumRepositoryNamesExceededException.prototype);
+    }
+}
+export class RepositoryNamesRequiredException extends __BaseException {
+    name = "RepositoryNamesRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNamesRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNamesRequiredException.prototype);
+    }
+}
+export class CommitDoesNotExistException extends __BaseException {
+    name = "CommitDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitDoesNotExistException.prototype);
+    }
+}
+export class CommitRequiredException extends __BaseException {
+    name = "CommitRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitRequiredException.prototype);
+    }
+}
+export class InvalidCommitException extends __BaseException {
+    name = "InvalidCommitException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCommitException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCommitException.prototype);
+    }
+}
+export class InvalidConflictDetailLevelException extends __BaseException {
+    name = "InvalidConflictDetailLevelException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidConflictDetailLevelException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidConflictDetailLevelException.prototype);
+    }
+}
+export class InvalidConflictResolutionStrategyException extends __BaseException {
+    name = "InvalidConflictResolutionStrategyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidConflictResolutionStrategyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidConflictResolutionStrategyException.prototype);
+    }
+}
+export class InvalidContinuationTokenException extends __BaseException {
+    name = "InvalidContinuationTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidContinuationTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidContinuationTokenException.prototype);
+    }
+}
+export class InvalidMaxConflictFilesException extends __BaseException {
+    name = "InvalidMaxConflictFilesException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMaxConflictFilesException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMaxConflictFilesException.prototype);
+    }
+}
+export class InvalidMaxMergeHunksException extends __BaseException {
+    name = "InvalidMaxMergeHunksException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMaxMergeHunksException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMaxMergeHunksException.prototype);
+    }
+}
+export class InvalidMergeOptionException extends __BaseException {
+    name = "InvalidMergeOptionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMergeOptionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMergeOptionException.prototype);
+    }
+}
+export class MaximumFileContentToLoadExceededException extends __BaseException {
+    name = "MaximumFileContentToLoadExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumFileContentToLoadExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumFileContentToLoadExceededException.prototype);
+    }
+}
+export class MaximumItemsToCompareExceededException extends __BaseException {
+    name = "MaximumItemsToCompareExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumItemsToCompareExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumItemsToCompareExceededException.prototype);
+    }
+}
+export class MergeOptionRequiredException extends __BaseException {
+    name = "MergeOptionRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MergeOptionRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MergeOptionRequiredException.prototype);
+    }
+}
+export class TipsDivergenceExceededException extends __BaseException {
+    name = "TipsDivergenceExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TipsDivergenceExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TipsDivergenceExceededException.prototype);
+    }
+}
+export class CommitIdsLimitExceededException extends __BaseException {
+    name = "CommitIdsLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitIdsLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitIdsLimitExceededException.prototype);
+    }
+}
+export class CommitIdsListRequiredException extends __BaseException {
+    name = "CommitIdsListRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitIdsListRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitIdsListRequiredException.prototype);
+    }
+}
+export class BeforeCommitIdAndAfterCommitIdAreSameException extends __BaseException {
+    name = "BeforeCommitIdAndAfterCommitIdAreSameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BeforeCommitIdAndAfterCommitIdAreSameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BeforeCommitIdAndAfterCommitIdAreSameException.prototype);
+    }
+}
+export class BlobIdDoesNotExistException extends __BaseException {
+    name = "BlobIdDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BlobIdDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BlobIdDoesNotExistException.prototype);
+    }
+}
+export class BlobIdRequiredException extends __BaseException {
+    name = "BlobIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BlobIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BlobIdRequiredException.prototype);
+    }
+}
+export class BranchDoesNotExistException extends __BaseException {
+    name = "BranchDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BranchDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BranchDoesNotExistException.prototype);
+    }
+}
+export class BranchNameExistsException extends __BaseException {
+    name = "BranchNameExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BranchNameExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BranchNameExistsException.prototype);
+    }
+}
+export class BranchNameIsTagNameException extends __BaseException {
+    name = "BranchNameIsTagNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BranchNameIsTagNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BranchNameIsTagNameException.prototype);
+    }
+}
+export class BranchNameRequiredException extends __BaseException {
+    name = "BranchNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "BranchNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, BranchNameRequiredException.prototype);
+    }
+}
+export class CannotDeleteApprovalRuleFromTemplateException extends __BaseException {
+    name = "CannotDeleteApprovalRuleFromTemplateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CannotDeleteApprovalRuleFromTemplateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CannotDeleteApprovalRuleFromTemplateException.prototype);
+    }
+}
+export class CannotModifyApprovalRuleFromTemplateException extends __BaseException {
+    name = "CannotModifyApprovalRuleFromTemplateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CannotModifyApprovalRuleFromTemplateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CannotModifyApprovalRuleFromTemplateException.prototype);
+    }
+}
+export class ClientRequestTokenRequiredException extends __BaseException {
+    name = "ClientRequestTokenRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ClientRequestTokenRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClientRequestTokenRequiredException.prototype);
+    }
+}
+export class InvalidApprovalRuleTemplateContentException extends __BaseException {
+    name = "InvalidApprovalRuleTemplateContentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalRuleTemplateContentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalRuleTemplateContentException.prototype);
+    }
+}
+export class InvalidApprovalRuleTemplateDescriptionException extends __BaseException {
+    name = "InvalidApprovalRuleTemplateDescriptionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalRuleTemplateDescriptionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalRuleTemplateDescriptionException.prototype);
+    }
+}
+export class NumberOfRuleTemplatesExceededException extends __BaseException {
+    name = "NumberOfRuleTemplatesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NumberOfRuleTemplatesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NumberOfRuleTemplatesExceededException.prototype);
+    }
+}
+export class CommitIdRequiredException extends __BaseException {
+    name = "CommitIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitIdRequiredException.prototype);
+    }
+}
+export class InvalidBranchNameException extends __BaseException {
+    name = "InvalidBranchNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidBranchNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidBranchNameException.prototype);
+    }
+}
+export class InvalidCommitIdException extends __BaseException {
+    name = "InvalidCommitIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCommitIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCommitIdException.prototype);
+    }
+}
+export class CommitMessageLengthExceededException extends __BaseException {
+    name = "CommitMessageLengthExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitMessageLengthExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitMessageLengthExceededException.prototype);
+    }
+}
+export class DirectoryNameConflictsWithFileNameException extends __BaseException {
+    name = "DirectoryNameConflictsWithFileNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DirectoryNameConflictsWithFileNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DirectoryNameConflictsWithFileNameException.prototype);
+    }
+}
+export class FileContentAndSourceFileSpecifiedException extends __BaseException {
+    name = "FileContentAndSourceFileSpecifiedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileContentAndSourceFileSpecifiedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileContentAndSourceFileSpecifiedException.prototype);
+    }
+}
+export class FileContentSizeLimitExceededException extends __BaseException {
+    name = "FileContentSizeLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileContentSizeLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileContentSizeLimitExceededException.prototype);
+    }
+}
+export class FileDoesNotExistException extends __BaseException {
+    name = "FileDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileDoesNotExistException.prototype);
+    }
+}
+export class FileEntryRequiredException extends __BaseException {
+    name = "FileEntryRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileEntryRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileEntryRequiredException.prototype);
+    }
+}
+export class FileModeRequiredException extends __BaseException {
+    name = "FileModeRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileModeRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileModeRequiredException.prototype);
+    }
+}
+export class FileNameConflictsWithDirectoryNameException extends __BaseException {
+    name = "FileNameConflictsWithDirectoryNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileNameConflictsWithDirectoryNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileNameConflictsWithDirectoryNameException.prototype);
+    }
+}
+export class FilePathConflictsWithSubmodulePathException extends __BaseException {
+    name = "FilePathConflictsWithSubmodulePathException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FilePathConflictsWithSubmodulePathException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FilePathConflictsWithSubmodulePathException.prototype);
+    }
+}
+export class FolderContentSizeLimitExceededException extends __BaseException {
+    name = "FolderContentSizeLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FolderContentSizeLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FolderContentSizeLimitExceededException.prototype);
+    }
+}
+export class InvalidDeletionParameterException extends __BaseException {
+    name = "InvalidDeletionParameterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDeletionParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDeletionParameterException.prototype);
+    }
+}
+export class InvalidEmailException extends __BaseException {
+    name = "InvalidEmailException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidEmailException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidEmailException.prototype);
+    }
+}
+export class InvalidFileModeException extends __BaseException {
+    name = "InvalidFileModeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidFileModeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidFileModeException.prototype);
+    }
+}
+export class InvalidParentCommitIdException extends __BaseException {
+    name = "InvalidParentCommitIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParentCommitIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParentCommitIdException.prototype);
+    }
+}
+export class InvalidPathException extends __BaseException {
+    name = "InvalidPathException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPathException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPathException.prototype);
+    }
+}
+export class MaximumFileEntriesExceededException extends __BaseException {
+    name = "MaximumFileEntriesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumFileEntriesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumFileEntriesExceededException.prototype);
+    }
+}
+export class NameLengthExceededException extends __BaseException {
+    name = "NameLengthExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NameLengthExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NameLengthExceededException.prototype);
+    }
+}
+export class NoChangeException extends __BaseException {
+    name = "NoChangeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NoChangeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NoChangeException.prototype);
+    }
+}
+export class ParentCommitDoesNotExistException extends __BaseException {
+    name = "ParentCommitDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParentCommitDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParentCommitDoesNotExistException.prototype);
+    }
+}
+export class ParentCommitIdOutdatedException extends __BaseException {
+    name = "ParentCommitIdOutdatedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParentCommitIdOutdatedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParentCommitIdOutdatedException.prototype);
+    }
+}
+export class ParentCommitIdRequiredException extends __BaseException {
+    name = "ParentCommitIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParentCommitIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParentCommitIdRequiredException.prototype);
+    }
+}
+export class PathRequiredException extends __BaseException {
+    name = "PathRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PathRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PathRequiredException.prototype);
+    }
+}
+export class PutFileEntryConflictException extends __BaseException {
+    name = "PutFileEntryConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PutFileEntryConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PutFileEntryConflictException.prototype);
+    }
+}
+export class RestrictedSourceFileException extends __BaseException {
+    name = "RestrictedSourceFileException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RestrictedSourceFileException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RestrictedSourceFileException.prototype);
+    }
+}
+export class SamePathRequestException extends __BaseException {
+    name = "SamePathRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SamePathRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SamePathRequestException.prototype);
+    }
+}
+export class SourceFileOrContentRequiredException extends __BaseException {
+    name = "SourceFileOrContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SourceFileOrContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SourceFileOrContentRequiredException.prototype);
+    }
+}
+export class IdempotencyParameterMismatchException extends __BaseException {
+    name = "IdempotencyParameterMismatchException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "IdempotencyParameterMismatchException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, IdempotencyParameterMismatchException.prototype);
+    }
+}
+export class InvalidClientRequestTokenException extends __BaseException {
+    name = "InvalidClientRequestTokenException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidClientRequestTokenException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidClientRequestTokenException.prototype);
+    }
+}
+export class InvalidDescriptionException extends __BaseException {
+    name = "InvalidDescriptionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDescriptionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDescriptionException.prototype);
+    }
+}
+export class InvalidReferenceNameException extends __BaseException {
+    name = "InvalidReferenceNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReferenceNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReferenceNameException.prototype);
+    }
+}
+export class InvalidTargetException extends __BaseException {
+    name = "InvalidTargetException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetException.prototype);
+    }
+}
+export class InvalidTargetsException extends __BaseException {
+    name = "InvalidTargetsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetsException.prototype);
+    }
+}
+export class InvalidTitleException extends __BaseException {
+    name = "InvalidTitleException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTitleException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTitleException.prototype);
+    }
+}
+export class MaximumOpenPullRequestsExceededException extends __BaseException {
+    name = "MaximumOpenPullRequestsExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumOpenPullRequestsExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumOpenPullRequestsExceededException.prototype);
+    }
+}
+export class MultipleRepositoriesInPullRequestException extends __BaseException {
+    name = "MultipleRepositoriesInPullRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MultipleRepositoriesInPullRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MultipleRepositoriesInPullRequestException.prototype);
+    }
+}
+export class ReferenceDoesNotExistException extends __BaseException {
+    name = "ReferenceDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReferenceDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReferenceDoesNotExistException.prototype);
+    }
+}
+export class ReferenceNameRequiredException extends __BaseException {
+    name = "ReferenceNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReferenceNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReferenceNameRequiredException.prototype);
+    }
+}
+export class ReferenceTypeNotSupportedException extends __BaseException {
+    name = "ReferenceTypeNotSupportedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReferenceTypeNotSupportedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReferenceTypeNotSupportedException.prototype);
+    }
+}
+export class SourceAndDestinationAreSameException extends __BaseException {
+    name = "SourceAndDestinationAreSameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SourceAndDestinationAreSameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SourceAndDestinationAreSameException.prototype);
+    }
+}
+export class TargetRequiredException extends __BaseException {
+    name = "TargetRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TargetRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TargetRequiredException.prototype);
+    }
+}
+export class TargetsRequiredException extends __BaseException {
+    name = "TargetsRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TargetsRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TargetsRequiredException.prototype);
+    }
+}
+export class TitleRequiredException extends __BaseException {
+    name = "TitleRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TitleRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TitleRequiredException.prototype);
+    }
+}
+export class InvalidApprovalRuleContentException extends __BaseException {
+    name = "InvalidApprovalRuleContentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalRuleContentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalRuleContentException.prototype);
+    }
+}
+export class InvalidApprovalRuleNameException extends __BaseException {
+    name = "InvalidApprovalRuleNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalRuleNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalRuleNameException.prototype);
+    }
+}
+export class InvalidPullRequestIdException extends __BaseException {
+    name = "InvalidPullRequestIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPullRequestIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPullRequestIdException.prototype);
+    }
+}
+export class NumberOfRulesExceededException extends __BaseException {
+    name = "NumberOfRulesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NumberOfRulesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NumberOfRulesExceededException.prototype);
+    }
+}
+export class PullRequestAlreadyClosedException extends __BaseException {
+    name = "PullRequestAlreadyClosedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestAlreadyClosedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestAlreadyClosedException.prototype);
+    }
+}
+export class PullRequestDoesNotExistException extends __BaseException {
+    name = "PullRequestDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestDoesNotExistException.prototype);
+    }
+}
+export class PullRequestIdRequiredException extends __BaseException {
+    name = "PullRequestIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestIdRequiredException.prototype);
+    }
+}
+export class EncryptionKeyInvalidIdException extends __BaseException {
+    name = "EncryptionKeyInvalidIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyInvalidIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyInvalidIdException.prototype);
+    }
+}
+export class EncryptionKeyInvalidUsageException extends __BaseException {
+    name = "EncryptionKeyInvalidUsageException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyInvalidUsageException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyInvalidUsageException.prototype);
+    }
+}
+export class InvalidRepositoryDescriptionException extends __BaseException {
+    name = "InvalidRepositoryDescriptionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryDescriptionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryDescriptionException.prototype);
+    }
+}
+export class InvalidSystemTagUsageException extends __BaseException {
+    name = "InvalidSystemTagUsageException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSystemTagUsageException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSystemTagUsageException.prototype);
+    }
+}
+export class InvalidTagsMapException extends __BaseException {
+    name = "InvalidTagsMapException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagsMapException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagsMapException.prototype);
+    }
+}
+export class OperationNotAllowedException extends __BaseException {
+    name = "OperationNotAllowedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "OperationNotAllowedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OperationNotAllowedException.prototype);
+    }
+}
+export class RepositoryLimitExceededException extends __BaseException {
+    name = "RepositoryLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryLimitExceededException.prototype);
+    }
+}
+export class RepositoryNameExistsException extends __BaseException {
+    name = "RepositoryNameExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNameExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNameExistsException.prototype);
+    }
+}
+export class TagPolicyException extends __BaseException {
+    name = "TagPolicyException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagPolicyException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagPolicyException.prototype);
+    }
+}
+export class TooManyTagsException extends __BaseException {
+    name = "TooManyTagsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TooManyTagsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTagsException.prototype);
+    }
+}
+export class ConcurrentReferenceUpdateException extends __BaseException {
+    name = "ConcurrentReferenceUpdateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConcurrentReferenceUpdateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentReferenceUpdateException.prototype);
+    }
+}
+export class InvalidConflictResolutionException extends __BaseException {
+    name = "InvalidConflictResolutionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidConflictResolutionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidConflictResolutionException.prototype);
+    }
+}
+export class InvalidReplacementContentException extends __BaseException {
+    name = "InvalidReplacementContentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReplacementContentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReplacementContentException.prototype);
+    }
+}
+export class InvalidReplacementTypeException extends __BaseException {
+    name = "InvalidReplacementTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReplacementTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReplacementTypeException.prototype);
+    }
+}
+export class ManualMergeRequiredException extends __BaseException {
+    name = "ManualMergeRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ManualMergeRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ManualMergeRequiredException.prototype);
+    }
+}
+export class MaximumConflictResolutionEntriesExceededException extends __BaseException {
+    name = "MaximumConflictResolutionEntriesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumConflictResolutionEntriesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumConflictResolutionEntriesExceededException.prototype);
+    }
+}
+export class MultipleConflictResolutionEntriesException extends __BaseException {
+    name = "MultipleConflictResolutionEntriesException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MultipleConflictResolutionEntriesException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MultipleConflictResolutionEntriesException.prototype);
+    }
+}
+export class ReplacementContentRequiredException extends __BaseException {
+    name = "ReplacementContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplacementContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplacementContentRequiredException.prototype);
+    }
+}
+export class ReplacementTypeRequiredException extends __BaseException {
+    name = "ReplacementTypeRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReplacementTypeRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReplacementTypeRequiredException.prototype);
+    }
+}
+export class DefaultBranchCannotBeDeletedException extends __BaseException {
+    name = "DefaultBranchCannotBeDeletedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DefaultBranchCannotBeDeletedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DefaultBranchCannotBeDeletedException.prototype);
+    }
+}
+export class CommentDeletedException extends __BaseException {
+    name = "CommentDeletedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentDeletedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentDeletedException.prototype);
+    }
+}
+export class CommentDoesNotExistException extends __BaseException {
+    name = "CommentDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentDoesNotExistException.prototype);
+    }
+}
+export class CommentIdRequiredException extends __BaseException {
+    name = "CommentIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentIdRequiredException.prototype);
+    }
+}
+export class InvalidCommentIdException extends __BaseException {
+    name = "InvalidCommentIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidCommentIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCommentIdException.prototype);
+    }
+}
+export class InvalidActorArnException extends __BaseException {
+    name = "InvalidActorArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidActorArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidActorArnException.prototype);
+    }
+}
+export class InvalidMaxResultsException extends __BaseException {
+    name = "InvalidMaxResultsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidMaxResultsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidMaxResultsException.prototype);
+    }
+}
+export class InvalidPullRequestEventTypeException extends __BaseException {
+    name = "InvalidPullRequestEventTypeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPullRequestEventTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPullRequestEventTypeException.prototype);
+    }
+}
+export class InvalidRevisionIdException extends __BaseException {
+    name = "InvalidRevisionIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRevisionIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRevisionIdException.prototype);
+    }
+}
+export class RevisionIdRequiredException extends __BaseException {
+    name = "RevisionIdRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RevisionIdRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RevisionIdRequiredException.prototype);
+    }
+}
+export class RevisionNotCurrentException extends __BaseException {
+    name = "RevisionNotCurrentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RevisionNotCurrentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RevisionNotCurrentException.prototype);
+    }
+}
+export class FileTooLargeException extends __BaseException {
+    name = "FileTooLargeException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileTooLargeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileTooLargeException.prototype);
+    }
+}
+export class InvalidBlobIdException extends __BaseException {
+    name = "InvalidBlobIdException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidBlobIdException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidBlobIdException.prototype);
+    }
+}
+export class InvalidReactionUserArnException extends __BaseException {
+    name = "InvalidReactionUserArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReactionUserArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReactionUserArnException.prototype);
+    }
+}
+export class RepositoryNotAssociatedWithPullRequestException extends __BaseException {
+    name = "RepositoryNotAssociatedWithPullRequestException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryNotAssociatedWithPullRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryNotAssociatedWithPullRequestException.prototype);
+    }
+}
+export class CommitIdDoesNotExistException extends __BaseException {
+    name = "CommitIdDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommitIdDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommitIdDoesNotExistException.prototype);
+    }
+}
+export class PathDoesNotExistException extends __BaseException {
+    name = "PathDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PathDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PathDoesNotExistException.prototype);
+    }
+}
+export class FolderDoesNotExistException extends __BaseException {
+    name = "FolderDoesNotExistException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FolderDoesNotExistException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FolderDoesNotExistException.prototype);
+    }
+}
+export class InvalidDestinationCommitSpecifierException extends __BaseException {
+    name = "InvalidDestinationCommitSpecifierException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDestinationCommitSpecifierException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDestinationCommitSpecifierException.prototype);
+    }
+}
+export class InvalidSourceCommitSpecifierException extends __BaseException {
+    name = "InvalidSourceCommitSpecifierException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSourceCommitSpecifierException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSourceCommitSpecifierException.prototype);
+    }
+}
+export class InvalidAuthorArnException extends __BaseException {
+    name = "InvalidAuthorArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidAuthorArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidAuthorArnException.prototype);
+    }
+}
+export class InvalidPullRequestStatusException extends __BaseException {
+    name = "InvalidPullRequestStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPullRequestStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPullRequestStatusException.prototype);
+    }
+}
+export class InvalidOrderException extends __BaseException {
+    name = "InvalidOrderException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOrderException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOrderException.prototype);
+    }
+}
+export class InvalidSortByException extends __BaseException {
+    name = "InvalidSortByException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSortByException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSortByException.prototype);
+    }
+}
+export class InvalidResourceArnException extends __BaseException {
+    name = "InvalidResourceArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidResourceArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidResourceArnException.prototype);
+    }
+}
+export class ResourceArnRequiredException extends __BaseException {
+    name = "ResourceArnRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceArnRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceArnRequiredException.prototype);
+    }
+}
+export class InvalidTargetBranchException extends __BaseException {
+    name = "InvalidTargetBranchException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTargetBranchException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTargetBranchException.prototype);
+    }
+}
+export class PullRequestApprovalRulesNotSatisfiedException extends __BaseException {
+    name = "PullRequestApprovalRulesNotSatisfiedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestApprovalRulesNotSatisfiedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestApprovalRulesNotSatisfiedException.prototype);
+    }
+}
+export class TipOfSourceReferenceIsDifferentException extends __BaseException {
+    name = "TipOfSourceReferenceIsDifferentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TipOfSourceReferenceIsDifferentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TipOfSourceReferenceIsDifferentException.prototype);
+    }
+}
+export class InvalidOverrideStatusException extends __BaseException {
+    name = "InvalidOverrideStatusException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOverrideStatusException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOverrideStatusException.prototype);
+    }
+}
+export class OverrideAlreadySetException extends __BaseException {
+    name = "OverrideAlreadySetException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "OverrideAlreadySetException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OverrideAlreadySetException.prototype);
+    }
+}
+export class OverrideStatusRequiredException extends __BaseException {
+    name = "OverrideStatusRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "OverrideStatusRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OverrideStatusRequiredException.prototype);
+    }
+}
+export class CommentContentRequiredException extends __BaseException {
+    name = "CommentContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentContentRequiredException.prototype);
+    }
+}
+export class CommentContentSizeLimitExceededException extends __BaseException {
+    name = "CommentContentSizeLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentContentSizeLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentContentSizeLimitExceededException.prototype);
+    }
+}
+export class InvalidFileLocationException extends __BaseException {
+    name = "InvalidFileLocationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidFileLocationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidFileLocationException.prototype);
+    }
+}
+export class InvalidFilePositionException extends __BaseException {
+    name = "InvalidFilePositionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidFilePositionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidFilePositionException.prototype);
+    }
+}
+export class InvalidRelativeFileVersionEnumException extends __BaseException {
+    name = "InvalidRelativeFileVersionEnumException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRelativeFileVersionEnumException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRelativeFileVersionEnumException.prototype);
+    }
+}
+export class InvalidReactionValueException extends __BaseException {
+    name = "InvalidReactionValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidReactionValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidReactionValueException.prototype);
+    }
+}
+export class ReactionLimitExceededException extends __BaseException {
+    name = "ReactionLimitExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReactionLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReactionLimitExceededException.prototype);
+    }
+}
+export class ReactionValueRequiredException extends __BaseException {
+    name = "ReactionValueRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ReactionValueRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ReactionValueRequiredException.prototype);
+    }
+}
+export class FileContentRequiredException extends __BaseException {
+    name = "FileContentRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "FileContentRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, FileContentRequiredException.prototype);
+    }
+}
+export class SameFileContentException extends __BaseException {
+    name = "SameFileContentException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SameFileContentException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SameFileContentException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerBranchNameException extends __BaseException {
+    name = "InvalidRepositoryTriggerBranchNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerBranchNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerBranchNameException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerCustomDataException extends __BaseException {
+    name = "InvalidRepositoryTriggerCustomDataException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerCustomDataException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerCustomDataException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerDestinationArnException extends __BaseException {
+    name = "InvalidRepositoryTriggerDestinationArnException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerDestinationArnException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerDestinationArnException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerEventsException extends __BaseException {
+    name = "InvalidRepositoryTriggerEventsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerEventsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerEventsException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerNameException extends __BaseException {
+    name = "InvalidRepositoryTriggerNameException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerNameException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerNameException.prototype);
+    }
+}
+export class InvalidRepositoryTriggerRegionException extends __BaseException {
+    name = "InvalidRepositoryTriggerRegionException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRepositoryTriggerRegionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRepositoryTriggerRegionException.prototype);
+    }
+}
+export class MaximumBranchesExceededException extends __BaseException {
+    name = "MaximumBranchesExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumBranchesExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumBranchesExceededException.prototype);
+    }
+}
+export class MaximumRepositoryTriggersExceededException extends __BaseException {
+    name = "MaximumRepositoryTriggersExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumRepositoryTriggersExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumRepositoryTriggersExceededException.prototype);
+    }
+}
+export class RepositoryTriggerBranchNameListRequiredException extends __BaseException {
+    name = "RepositoryTriggerBranchNameListRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryTriggerBranchNameListRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryTriggerBranchNameListRequiredException.prototype);
+    }
+}
+export class RepositoryTriggerDestinationArnRequiredException extends __BaseException {
+    name = "RepositoryTriggerDestinationArnRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryTriggerDestinationArnRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryTriggerDestinationArnRequiredException.prototype);
+    }
+}
+export class RepositoryTriggerEventsListRequiredException extends __BaseException {
+    name = "RepositoryTriggerEventsListRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryTriggerEventsListRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryTriggerEventsListRequiredException.prototype);
+    }
+}
+export class RepositoryTriggerNameRequiredException extends __BaseException {
+    name = "RepositoryTriggerNameRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryTriggerNameRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryTriggerNameRequiredException.prototype);
+    }
+}
+export class RepositoryTriggersListRequiredException extends __BaseException {
+    name = "RepositoryTriggersListRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "RepositoryTriggersListRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RepositoryTriggersListRequiredException.prototype);
+    }
+}
+export class TagsMapRequiredException extends __BaseException {
+    name = "TagsMapRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagsMapRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagsMapRequiredException.prototype);
+    }
+}
+export class InvalidTagKeysListException extends __BaseException {
+    name = "InvalidTagKeysListException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTagKeysListException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTagKeysListException.prototype);
+    }
+}
+export class TagKeysListRequiredException extends __BaseException {
+    name = "TagKeysListRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagKeysListRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagKeysListRequiredException.prototype);
+    }
+}
+export class InvalidRuleContentSha256Exception extends __BaseException {
+    name = "InvalidRuleContentSha256Exception";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidRuleContentSha256Exception",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRuleContentSha256Exception.prototype);
+    }
+}
+export class CommentNotCreatedByCallerException extends __BaseException {
+    name = "CommentNotCreatedByCallerException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "CommentNotCreatedByCallerException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, CommentNotCreatedByCallerException.prototype);
+    }
+}
+export class InvalidApprovalStateException extends __BaseException {
+    name = "InvalidApprovalStateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidApprovalStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidApprovalStateException.prototype);
+    }
+}
+export class MaximumNumberOfApprovalsExceededException extends __BaseException {
+    name = "MaximumNumberOfApprovalsExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MaximumNumberOfApprovalsExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MaximumNumberOfApprovalsExceededException.prototype);
+    }
+}
+export class PullRequestCannotBeApprovedByAuthorException extends __BaseException {
+    name = "PullRequestCannotBeApprovedByAuthorException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestCannotBeApprovedByAuthorException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestCannotBeApprovedByAuthorException.prototype);
+    }
+}
+export class InvalidPullRequestStatusUpdateException extends __BaseException {
+    name = "InvalidPullRequestStatusUpdateException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidPullRequestStatusUpdateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidPullRequestStatusUpdateException.prototype);
+    }
+}
+export class PullRequestStatusRequiredException extends __BaseException {
+    name = "PullRequestStatusRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "PullRequestStatusRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PullRequestStatusRequiredException.prototype);
+    }
+}
+export class EncryptionKeyRequiredException extends __BaseException {
+    name = "EncryptionKeyRequiredException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "EncryptionKeyRequiredException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, EncryptionKeyRequiredException.prototype);
+    }
+}