@aws-sdk/client-codecommit 3.52.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -1,10 +1,11 @@
-import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CodeCommitServiceException as __BaseException } from "./CodeCommitServiceException";
 
-export interface ActorDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "ActorDoesNotExistException";
-    $fault: "client";
+export declare class ActorDoesNotExistException extends __BaseException {
+    readonly name: "ActorDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ActorDoesNotExistException, __BaseException>);
 }
 export declare enum ApprovalState {
     APPROVE = "APPROVE",
@@ -56,18 +57,18 @@ export declare namespace ApprovalRule {
     const filterSensitiveLog: (obj: ApprovalRule) => any;
 }
 
-export interface ApprovalRuleContentRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleContentRequiredException";
-    $fault: "client";
+export declare class ApprovalRuleContentRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleContentRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleContentRequiredException, __BaseException>);
 }
 
-export interface ApprovalRuleDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleDoesNotExistException";
-    $fault: "client";
+export declare class ApprovalRuleDoesNotExistException extends __BaseException {
+    readonly name: "ApprovalRuleDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleDoesNotExistException, __BaseException>);
 }
 
 export interface ApprovalRuleEventMetadata {
@@ -83,18 +84,18 @@ export declare namespace ApprovalRuleEventMetadata {
     const filterSensitiveLog: (obj: ApprovalRuleEventMetadata) => any;
 }
 
-export interface ApprovalRuleNameAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleNameAlreadyExistsException";
-    $fault: "client";
+export declare class ApprovalRuleNameAlreadyExistsException extends __BaseException {
+    readonly name: "ApprovalRuleNameAlreadyExistsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleNameAlreadyExistsException, __BaseException>);
 }
 
-export interface ApprovalRuleNameRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleNameRequiredException";
-    $fault: "client";
+export declare class ApprovalRuleNameRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleNameRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleNameRequiredException, __BaseException>);
 }
 export declare enum OverrideStatus {
     OVERRIDE = "OVERRIDE",
@@ -135,39 +136,39 @@ export declare namespace ApprovalRuleTemplate {
     const filterSensitiveLog: (obj: ApprovalRuleTemplate) => any;
 }
 
-export interface ApprovalRuleTemplateContentRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleTemplateContentRequiredException";
-    $fault: "client";
+export declare class ApprovalRuleTemplateContentRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateContentRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateContentRequiredException, __BaseException>);
 }
 
-export interface ApprovalRuleTemplateDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleTemplateDoesNotExistException";
-    $fault: "client";
+export declare class ApprovalRuleTemplateDoesNotExistException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateDoesNotExistException, __BaseException>);
 }
 
-export interface ApprovalRuleTemplateInUseException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleTemplateInUseException";
-    $fault: "client";
+export declare class ApprovalRuleTemplateInUseException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateInUseException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateInUseException, __BaseException>);
 }
 
-export interface ApprovalRuleTemplateNameAlreadyExistsException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleTemplateNameAlreadyExistsException";
-    $fault: "client";
+export declare class ApprovalRuleTemplateNameAlreadyExistsException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateNameAlreadyExistsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateNameAlreadyExistsException, __BaseException>);
 }
 
-export interface ApprovalRuleTemplateNameRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalRuleTemplateNameRequiredException";
-    $fault: "client";
+export declare class ApprovalRuleTemplateNameRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateNameRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateNameRequiredException, __BaseException>);
 }
 
 export interface ApprovalStateChangedEventMetadata {
@@ -181,11 +182,11 @@ export declare namespace ApprovalStateChangedEventMetadata {
     const filterSensitiveLog: (obj: ApprovalStateChangedEventMetadata) => any;
 }
 
-export interface ApprovalStateRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ApprovalStateRequiredException";
-    $fault: "client";
+export declare class ApprovalStateRequiredException extends __BaseException {
+    readonly name: "ApprovalStateRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ApprovalStateRequiredException, __BaseException>);
 }
 export interface AssociateApprovalRuleTemplateWithRepositoryInput {
     
@@ -198,81 +199,81 @@ export declare namespace AssociateApprovalRuleTemplateWithRepositoryInput {
     const filterSensitiveLog: (obj: AssociateApprovalRuleTemplateWithRepositoryInput) => any;
 }
 
-export interface EncryptionIntegrityChecksFailedException extends __SmithyException, $MetadataBearer {
-    name: "EncryptionIntegrityChecksFailedException";
-    $fault: "server";
+export declare class EncryptionIntegrityChecksFailedException extends __BaseException {
+    readonly name: "EncryptionIntegrityChecksFailedException";
+    readonly $fault: "server";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<EncryptionIntegrityChecksFailedException, __BaseException>);
 }
 
-export interface EncryptionKeyAccessDeniedException extends __SmithyException, $MetadataBearer {
-    name: "EncryptionKeyAccessDeniedException";
-    $fault: "client";
+export declare class EncryptionKeyAccessDeniedException extends __BaseException {
+    readonly name: "EncryptionKeyAccessDeniedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<EncryptionKeyAccessDeniedException, __BaseException>);
 }
 
-export interface EncryptionKeyDisabledException extends __SmithyException, $MetadataBearer {
-    name: "EncryptionKeyDisabledException";
-    $fault: "client";
+export declare class EncryptionKeyDisabledException extends __BaseException {
+    readonly name: "EncryptionKeyDisabledException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<EncryptionKeyDisabledException, __BaseException>);
 }
 
-export interface EncryptionKeyNotFoundException extends __SmithyException, $MetadataBearer {
-    name: "EncryptionKeyNotFoundException";
-    $fault: "client";
+export declare class EncryptionKeyNotFoundException extends __BaseException {
+    readonly name: "EncryptionKeyNotFoundException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<EncryptionKeyNotFoundException, __BaseException>);
 }
 
-export interface EncryptionKeyUnavailableException extends __SmithyException, $MetadataBearer {
-    name: "EncryptionKeyUnavailableException";
-    $fault: "client";
+export declare class EncryptionKeyUnavailableException extends __BaseException {
+    readonly name: "EncryptionKeyUnavailableException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<EncryptionKeyUnavailableException, __BaseException>);
 }
 
-export interface InvalidApprovalRuleTemplateNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidApprovalRuleTemplateNameException";
-    $fault: "client";
+export declare class InvalidApprovalRuleTemplateNameException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateNameException, __BaseException>);
 }
 
-export interface InvalidRepositoryNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidRepositoryNameException";
-    $fault: "client";
+export declare class InvalidRepositoryNameException extends __BaseException {
+    readonly name: "InvalidRepositoryNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidRepositoryNameException, __BaseException>);
 }
 
-export interface MaximumRuleTemplatesAssociatedWithRepositoryException extends __SmithyException, $MetadataBearer {
-    name: "MaximumRuleTemplatesAssociatedWithRepositoryException";
-    $fault: "client";
+export declare class MaximumRuleTemplatesAssociatedWithRepositoryException extends __BaseException {
+    readonly name: "MaximumRuleTemplatesAssociatedWithRepositoryException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumRuleTemplatesAssociatedWithRepositoryException, __BaseException>);
 }
 
-export interface RepositoryDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryDoesNotExistException";
-    $fault: "client";
+export declare class RepositoryDoesNotExistException extends __BaseException {
+    readonly name: "RepositoryDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryDoesNotExistException, __BaseException>);
 }
 
-export interface RepositoryNameRequiredException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryNameRequiredException";
-    $fault: "client";
+export declare class RepositoryNameRequiredException extends __BaseException {
+    readonly name: "RepositoryNameRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryNameRequiredException, __BaseException>);
 }
 
-export interface AuthorDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "AuthorDoesNotExistException";
-    $fault: "client";
+export declare class AuthorDoesNotExistException extends __BaseException {
+    readonly name: "AuthorDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<AuthorDoesNotExistException, __BaseException>);
 }
 export interface BatchAssociateApprovalRuleTemplateWithRepositoriesInput {
     
@@ -308,18 +309,18 @@ export declare namespace BatchAssociateApprovalRuleTemplateWithRepositoriesOutpu
     const filterSensitiveLog: (obj: BatchAssociateApprovalRuleTemplateWithRepositoriesOutput) => any;
 }
 
-export interface MaximumRepositoryNamesExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumRepositoryNamesExceededException";
-    $fault: "client";
+export declare class MaximumRepositoryNamesExceededException extends __BaseException {
+    readonly name: "MaximumRepositoryNamesExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumRepositoryNamesExceededException, __BaseException>);
 }
 
-export interface RepositoryNamesRequiredException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryNamesRequiredException";
-    $fault: "client";
+export declare class RepositoryNamesRequiredException extends __BaseException {
+    readonly name: "RepositoryNamesRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryNamesRequiredException, __BaseException>);
 }
 export declare enum ConflictDetailLevelTypeEnum {
     FILE_LEVEL = "FILE_LEVEL",
@@ -539,95 +540,95 @@ export declare namespace BatchDescribeMergeConflictsOutput {
     const filterSensitiveLog: (obj: BatchDescribeMergeConflictsOutput) => any;
 }
 
-export interface CommitDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "CommitDoesNotExistException";
-    $fault: "client";
+export declare class CommitDoesNotExistException extends __BaseException {
+    readonly name: "CommitDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitDoesNotExistException, __BaseException>);
 }
 
-export interface CommitRequiredException extends __SmithyException, $MetadataBearer {
-    name: "CommitRequiredException";
-    $fault: "client";
+export declare class CommitRequiredException extends __BaseException {
+    readonly name: "CommitRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitRequiredException, __BaseException>);
 }
 
-export interface InvalidCommitException extends __SmithyException, $MetadataBearer {
-    name: "InvalidCommitException";
-    $fault: "client";
+export declare class InvalidCommitException extends __BaseException {
+    readonly name: "InvalidCommitException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidCommitException, __BaseException>);
 }
 
-export interface InvalidConflictDetailLevelException extends __SmithyException, $MetadataBearer {
-    name: "InvalidConflictDetailLevelException";
-    $fault: "client";
+export declare class InvalidConflictDetailLevelException extends __BaseException {
+    readonly name: "InvalidConflictDetailLevelException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidConflictDetailLevelException, __BaseException>);
 }
 
-export interface InvalidConflictResolutionStrategyException extends __SmithyException, $MetadataBearer {
-    name: "InvalidConflictResolutionStrategyException";
-    $fault: "client";
+export declare class InvalidConflictResolutionStrategyException extends __BaseException {
+    readonly name: "InvalidConflictResolutionStrategyException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidConflictResolutionStrategyException, __BaseException>);
 }
 
-export interface InvalidContinuationTokenException extends __SmithyException, $MetadataBearer {
-    name: "InvalidContinuationTokenException";
-    $fault: "client";
+export declare class InvalidContinuationTokenException extends __BaseException {
+    readonly name: "InvalidContinuationTokenException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidContinuationTokenException, __BaseException>);
 }
 
-export interface InvalidMaxConflictFilesException extends __SmithyException, $MetadataBearer {
-    name: "InvalidMaxConflictFilesException";
-    $fault: "client";
+export declare class InvalidMaxConflictFilesException extends __BaseException {
+    readonly name: "InvalidMaxConflictFilesException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidMaxConflictFilesException, __BaseException>);
 }
 
-export interface InvalidMaxMergeHunksException extends __SmithyException, $MetadataBearer {
-    name: "InvalidMaxMergeHunksException";
-    $fault: "client";
+export declare class InvalidMaxMergeHunksException extends __BaseException {
+    readonly name: "InvalidMaxMergeHunksException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidMaxMergeHunksException, __BaseException>);
 }
 
-export interface InvalidMergeOptionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidMergeOptionException";
-    $fault: "client";
+export declare class InvalidMergeOptionException extends __BaseException {
+    readonly name: "InvalidMergeOptionException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidMergeOptionException, __BaseException>);
 }
 
-export interface MaximumFileContentToLoadExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumFileContentToLoadExceededException";
-    $fault: "client";
+export declare class MaximumFileContentToLoadExceededException extends __BaseException {
+    readonly name: "MaximumFileContentToLoadExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumFileContentToLoadExceededException, __BaseException>);
 }
 
-export interface MaximumItemsToCompareExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumItemsToCompareExceededException";
-    $fault: "client";
+export declare class MaximumItemsToCompareExceededException extends __BaseException {
+    readonly name: "MaximumItemsToCompareExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumItemsToCompareExceededException, __BaseException>);
 }
 
-export interface MergeOptionRequiredException extends __SmithyException, $MetadataBearer {
-    name: "MergeOptionRequiredException";
-    $fault: "client";
+export declare class MergeOptionRequiredException extends __BaseException {
+    readonly name: "MergeOptionRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MergeOptionRequiredException, __BaseException>);
 }
 
-export interface TipsDivergenceExceededException extends __SmithyException, $MetadataBearer {
-    name: "TipsDivergenceExceededException";
-    $fault: "client";
+export declare class TipsDivergenceExceededException extends __BaseException {
+    readonly name: "TipsDivergenceExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TipsDivergenceExceededException, __BaseException>);
 }
 export interface BatchDisassociateApprovalRuleTemplateFromRepositoriesInput {
     
@@ -730,18 +731,18 @@ export declare namespace BatchGetCommitsOutput {
     const filterSensitiveLog: (obj: BatchGetCommitsOutput) => any;
 }
 
-export interface CommitIdsLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "CommitIdsLimitExceededException";
-    $fault: "client";
+export declare class CommitIdsLimitExceededException extends __BaseException {
+    readonly name: "CommitIdsLimitExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitIdsLimitExceededException, __BaseException>);
 }
 
-export interface CommitIdsListRequiredException extends __SmithyException, $MetadataBearer {
-    name: "CommitIdsListRequiredException";
-    $fault: "client";
+export declare class CommitIdsListRequiredException extends __BaseException {
+    readonly name: "CommitIdsListRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitIdsListRequiredException, __BaseException>);
 }
 
 export interface BatchGetRepositoriesInput {
@@ -791,25 +792,25 @@ export declare namespace BatchGetRepositoriesOutput {
     const filterSensitiveLog: (obj: BatchGetRepositoriesOutput) => any;
 }
 
-export interface BeforeCommitIdAndAfterCommitIdAreSameException extends __SmithyException, $MetadataBearer {
-    name: "BeforeCommitIdAndAfterCommitIdAreSameException";
-    $fault: "client";
+export declare class BeforeCommitIdAndAfterCommitIdAreSameException extends __BaseException {
+    readonly name: "BeforeCommitIdAndAfterCommitIdAreSameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BeforeCommitIdAndAfterCommitIdAreSameException, __BaseException>);
 }
 
-export interface BlobIdDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "BlobIdDoesNotExistException";
-    $fault: "client";
+export declare class BlobIdDoesNotExistException extends __BaseException {
+    readonly name: "BlobIdDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BlobIdDoesNotExistException, __BaseException>);
 }
 
-export interface BlobIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "BlobIdRequiredException";
-    $fault: "client";
+export declare class BlobIdRequiredException extends __BaseException {
+    readonly name: "BlobIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BlobIdRequiredException, __BaseException>);
 }
 
 export interface BlobMetadata {
@@ -825,11 +826,11 @@ export declare namespace BlobMetadata {
     const filterSensitiveLog: (obj: BlobMetadata) => any;
 }
 
-export interface BranchDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "BranchDoesNotExistException";
-    $fault: "client";
+export declare class BranchDoesNotExistException extends __BaseException {
+    readonly name: "BranchDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BranchDoesNotExistException, __BaseException>);
 }
 
 export interface BranchInfo {
@@ -843,46 +844,46 @@ export declare namespace BranchInfo {
     const filterSensitiveLog: (obj: BranchInfo) => any;
 }
 
-export interface BranchNameExistsException extends __SmithyException, $MetadataBearer {
-    name: "BranchNameExistsException";
-    $fault: "client";
+export declare class BranchNameExistsException extends __BaseException {
+    readonly name: "BranchNameExistsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BranchNameExistsException, __BaseException>);
 }
 
-export interface BranchNameIsTagNameException extends __SmithyException, $MetadataBearer {
-    name: "BranchNameIsTagNameException";
-    $fault: "client";
+export declare class BranchNameIsTagNameException extends __BaseException {
+    readonly name: "BranchNameIsTagNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BranchNameIsTagNameException, __BaseException>);
 }
 
-export interface BranchNameRequiredException extends __SmithyException, $MetadataBearer {
-    name: "BranchNameRequiredException";
-    $fault: "client";
+export declare class BranchNameRequiredException extends __BaseException {
+    readonly name: "BranchNameRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<BranchNameRequiredException, __BaseException>);
 }
 
-export interface CannotDeleteApprovalRuleFromTemplateException extends __SmithyException, $MetadataBearer {
-    name: "CannotDeleteApprovalRuleFromTemplateException";
-    $fault: "client";
+export declare class CannotDeleteApprovalRuleFromTemplateException extends __BaseException {
+    readonly name: "CannotDeleteApprovalRuleFromTemplateException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CannotDeleteApprovalRuleFromTemplateException, __BaseException>);
 }
 
-export interface CannotModifyApprovalRuleFromTemplateException extends __SmithyException, $MetadataBearer {
-    name: "CannotModifyApprovalRuleFromTemplateException";
-    $fault: "client";
+export declare class CannotModifyApprovalRuleFromTemplateException extends __BaseException {
+    readonly name: "CannotModifyApprovalRuleFromTemplateException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CannotModifyApprovalRuleFromTemplateException, __BaseException>);
 }
 
-export interface ClientRequestTokenRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ClientRequestTokenRequiredException";
-    $fault: "client";
+export declare class ClientRequestTokenRequiredException extends __BaseException {
+    readonly name: "ClientRequestTokenRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ClientRequestTokenRequiredException, __BaseException>);
 }
 export interface CreateApprovalRuleTemplateInput {
     
@@ -905,32 +906,32 @@ export declare namespace CreateApprovalRuleTemplateOutput {
     const filterSensitiveLog: (obj: CreateApprovalRuleTemplateOutput) => any;
 }
 
-export interface InvalidApprovalRuleTemplateContentException extends __SmithyException, $MetadataBearer {
-    name: "InvalidApprovalRuleTemplateContentException";
-    $fault: "client";
+export declare class InvalidApprovalRuleTemplateContentException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateContentException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateContentException, __BaseException>);
 }
 
-export interface InvalidApprovalRuleTemplateDescriptionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidApprovalRuleTemplateDescriptionException";
-    $fault: "client";
+export declare class InvalidApprovalRuleTemplateDescriptionException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateDescriptionException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateDescriptionException, __BaseException>);
 }
 
-export interface NumberOfRuleTemplatesExceededException extends __SmithyException, $MetadataBearer {
-    name: "NumberOfRuleTemplatesExceededException";
-    $fault: "client";
+export declare class NumberOfRuleTemplatesExceededException extends __BaseException {
+    readonly name: "NumberOfRuleTemplatesExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<NumberOfRuleTemplatesExceededException, __BaseException>);
 }
 
-export interface CommitIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "CommitIdRequiredException";
-    $fault: "client";
+export declare class CommitIdRequiredException extends __BaseException {
+    readonly name: "CommitIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitIdRequiredException, __BaseException>);
 }
 
 export interface CreateBranchInput {
@@ -946,25 +947,25 @@ export declare namespace CreateBranchInput {
     const filterSensitiveLog: (obj: CreateBranchInput) => any;
 }
 
-export interface InvalidBranchNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidBranchNameException";
-    $fault: "client";
+export declare class InvalidBranchNameException extends __BaseException {
+    readonly name: "InvalidBranchNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidBranchNameException, __BaseException>);
 }
 
-export interface InvalidCommitIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidCommitIdException";
-    $fault: "client";
+export declare class InvalidCommitIdException extends __BaseException {
+    readonly name: "InvalidCommitIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidCommitIdException, __BaseException>);
 }
 
-export interface CommitMessageLengthExceededException extends __SmithyException, $MetadataBearer {
-    name: "CommitMessageLengthExceededException";
-    $fault: "client";
+export declare class CommitMessageLengthExceededException extends __BaseException {
+    readonly name: "CommitMessageLengthExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitMessageLengthExceededException, __BaseException>);
 }
 
 export interface DeleteFileEntry {
@@ -1068,179 +1069,179 @@ export declare namespace CreateCommitOutput {
     const filterSensitiveLog: (obj: CreateCommitOutput) => any;
 }
 
-export interface DirectoryNameConflictsWithFileNameException extends __SmithyException, $MetadataBearer {
-    name: "DirectoryNameConflictsWithFileNameException";
-    $fault: "client";
+export declare class DirectoryNameConflictsWithFileNameException extends __BaseException {
+    readonly name: "DirectoryNameConflictsWithFileNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<DirectoryNameConflictsWithFileNameException, __BaseException>);
 }
 
-export interface FileContentAndSourceFileSpecifiedException extends __SmithyException, $MetadataBearer {
-    name: "FileContentAndSourceFileSpecifiedException";
-    $fault: "client";
+export declare class FileContentAndSourceFileSpecifiedException extends __BaseException {
+    readonly name: "FileContentAndSourceFileSpecifiedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileContentAndSourceFileSpecifiedException, __BaseException>);
 }
 
-export interface FileContentSizeLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "FileContentSizeLimitExceededException";
-    $fault: "client";
+export declare class FileContentSizeLimitExceededException extends __BaseException {
+    readonly name: "FileContentSizeLimitExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileContentSizeLimitExceededException, __BaseException>);
 }
 
-export interface FileDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "FileDoesNotExistException";
-    $fault: "client";
+export declare class FileDoesNotExistException extends __BaseException {
+    readonly name: "FileDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileDoesNotExistException, __BaseException>);
 }
 
-export interface FileEntryRequiredException extends __SmithyException, $MetadataBearer {
-    name: "FileEntryRequiredException";
-    $fault: "client";
+export declare class FileEntryRequiredException extends __BaseException {
+    readonly name: "FileEntryRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileEntryRequiredException, __BaseException>);
 }
 
-export interface FileModeRequiredException extends __SmithyException, $MetadataBearer {
-    name: "FileModeRequiredException";
-    $fault: "client";
+export declare class FileModeRequiredException extends __BaseException {
+    readonly name: "FileModeRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileModeRequiredException, __BaseException>);
 }
 
-export interface FileNameConflictsWithDirectoryNameException extends __SmithyException, $MetadataBearer {
-    name: "FileNameConflictsWithDirectoryNameException";
-    $fault: "client";
+export declare class FileNameConflictsWithDirectoryNameException extends __BaseException {
+    readonly name: "FileNameConflictsWithDirectoryNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileNameConflictsWithDirectoryNameException, __BaseException>);
 }
 
-export interface FilePathConflictsWithSubmodulePathException extends __SmithyException, $MetadataBearer {
-    name: "FilePathConflictsWithSubmodulePathException";
-    $fault: "client";
+export declare class FilePathConflictsWithSubmodulePathException extends __BaseException {
+    readonly name: "FilePathConflictsWithSubmodulePathException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FilePathConflictsWithSubmodulePathException, __BaseException>);
 }
 
-export interface FolderContentSizeLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "FolderContentSizeLimitExceededException";
-    $fault: "client";
+export declare class FolderContentSizeLimitExceededException extends __BaseException {
+    readonly name: "FolderContentSizeLimitExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FolderContentSizeLimitExceededException, __BaseException>);
 }
 
-export interface InvalidDeletionParameterException extends __SmithyException, $MetadataBearer {
-    name: "InvalidDeletionParameterException";
-    $fault: "client";
+export declare class InvalidDeletionParameterException extends __BaseException {
+    readonly name: "InvalidDeletionParameterException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidDeletionParameterException, __BaseException>);
 }
 
-export interface InvalidEmailException extends __SmithyException, $MetadataBearer {
-    name: "InvalidEmailException";
-    $fault: "client";
+export declare class InvalidEmailException extends __BaseException {
+    readonly name: "InvalidEmailException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidEmailException, __BaseException>);
 }
 
-export interface InvalidFileModeException extends __SmithyException, $MetadataBearer {
-    name: "InvalidFileModeException";
-    $fault: "client";
+export declare class InvalidFileModeException extends __BaseException {
+    readonly name: "InvalidFileModeException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidFileModeException, __BaseException>);
 }
 
-export interface InvalidParentCommitIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidParentCommitIdException";
-    $fault: "client";
+export declare class InvalidParentCommitIdException extends __BaseException {
+    readonly name: "InvalidParentCommitIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidParentCommitIdException, __BaseException>);
 }
 
-export interface InvalidPathException extends __SmithyException, $MetadataBearer {
-    name: "InvalidPathException";
-    $fault: "client";
+export declare class InvalidPathException extends __BaseException {
+    readonly name: "InvalidPathException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidPathException, __BaseException>);
 }
 
-export interface MaximumFileEntriesExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumFileEntriesExceededException";
-    $fault: "client";
+export declare class MaximumFileEntriesExceededException extends __BaseException {
+    readonly name: "MaximumFileEntriesExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumFileEntriesExceededException, __BaseException>);
 }
 
-export interface NameLengthExceededException extends __SmithyException, $MetadataBearer {
-    name: "NameLengthExceededException";
-    $fault: "client";
+export declare class NameLengthExceededException extends __BaseException {
+    readonly name: "NameLengthExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<NameLengthExceededException, __BaseException>);
 }
 
-export interface NoChangeException extends __SmithyException, $MetadataBearer {
-    name: "NoChangeException";
-    $fault: "client";
+export declare class NoChangeException extends __BaseException {
+    readonly name: "NoChangeException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<NoChangeException, __BaseException>);
 }
 
-export interface ParentCommitDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "ParentCommitDoesNotExistException";
-    $fault: "client";
+export declare class ParentCommitDoesNotExistException extends __BaseException {
+    readonly name: "ParentCommitDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ParentCommitDoesNotExistException, __BaseException>);
 }
 
-export interface ParentCommitIdOutdatedException extends __SmithyException, $MetadataBearer {
-    name: "ParentCommitIdOutdatedException";
-    $fault: "client";
+export declare class ParentCommitIdOutdatedException extends __BaseException {
+    readonly name: "ParentCommitIdOutdatedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ParentCommitIdOutdatedException, __BaseException>);
 }
 
-export interface ParentCommitIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ParentCommitIdRequiredException";
-    $fault: "client";
+export declare class ParentCommitIdRequiredException extends __BaseException {
+    readonly name: "ParentCommitIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ParentCommitIdRequiredException, __BaseException>);
 }
 
-export interface PathRequiredException extends __SmithyException, $MetadataBearer {
-    name: "PathRequiredException";
-    $fault: "client";
+export declare class PathRequiredException extends __BaseException {
+    readonly name: "PathRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PathRequiredException, __BaseException>);
 }
 
-export interface PutFileEntryConflictException extends __SmithyException, $MetadataBearer {
-    name: "PutFileEntryConflictException";
-    $fault: "client";
+export declare class PutFileEntryConflictException extends __BaseException {
+    readonly name: "PutFileEntryConflictException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PutFileEntryConflictException, __BaseException>);
 }
 
-export interface RestrictedSourceFileException extends __SmithyException, $MetadataBearer {
-    name: "RestrictedSourceFileException";
-    $fault: "client";
+export declare class RestrictedSourceFileException extends __BaseException {
+    readonly name: "RestrictedSourceFileException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RestrictedSourceFileException, __BaseException>);
 }
 
-export interface SamePathRequestException extends __SmithyException, $MetadataBearer {
-    name: "SamePathRequestException";
-    $fault: "client";
+export declare class SamePathRequestException extends __BaseException {
+    readonly name: "SamePathRequestException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<SamePathRequestException, __BaseException>);
 }
 
-export interface SourceFileOrContentRequiredException extends __SmithyException, $MetadataBearer {
-    name: "SourceFileOrContentRequiredException";
-    $fault: "client";
+export declare class SourceFileOrContentRequiredException extends __BaseException {
+    readonly name: "SourceFileOrContentRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<SourceFileOrContentRequiredException, __BaseException>);
 }
 
 export interface Target {
@@ -1347,116 +1348,116 @@ export declare namespace CreatePullRequestOutput {
     const filterSensitiveLog: (obj: CreatePullRequestOutput) => any;
 }
 
-export interface IdempotencyParameterMismatchException extends __SmithyException, $MetadataBearer {
-    name: "IdempotencyParameterMismatchException";
-    $fault: "client";
+export declare class IdempotencyParameterMismatchException extends __BaseException {
+    readonly name: "IdempotencyParameterMismatchException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<IdempotencyParameterMismatchException, __BaseException>);
 }
 
-export interface InvalidClientRequestTokenException extends __SmithyException, $MetadataBearer {
-    name: "InvalidClientRequestTokenException";
-    $fault: "client";
+export declare class InvalidClientRequestTokenException extends __BaseException {
+    readonly name: "InvalidClientRequestTokenException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidClientRequestTokenException, __BaseException>);
 }
 
-export interface InvalidDescriptionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidDescriptionException";
-    $fault: "client";
+export declare class InvalidDescriptionException extends __BaseException {
+    readonly name: "InvalidDescriptionException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidDescriptionException, __BaseException>);
 }
 
-export interface InvalidReferenceNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidReferenceNameException";
-    $fault: "client";
+export declare class InvalidReferenceNameException extends __BaseException {
+    readonly name: "InvalidReferenceNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidReferenceNameException, __BaseException>);
 }
 
-export interface InvalidTargetException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTargetException";
-    $fault: "client";
+export declare class InvalidTargetException extends __BaseException {
+    readonly name: "InvalidTargetException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidTargetException, __BaseException>);
 }
 
-export interface InvalidTargetsException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTargetsException";
-    $fault: "client";
+export declare class InvalidTargetsException extends __BaseException {
+    readonly name: "InvalidTargetsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidTargetsException, __BaseException>);
 }
 
-export interface InvalidTitleException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTitleException";
-    $fault: "client";
+export declare class InvalidTitleException extends __BaseException {
+    readonly name: "InvalidTitleException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidTitleException, __BaseException>);
 }
 
-export interface MaximumOpenPullRequestsExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumOpenPullRequestsExceededException";
-    $fault: "client";
+export declare class MaximumOpenPullRequestsExceededException extends __BaseException {
+    readonly name: "MaximumOpenPullRequestsExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumOpenPullRequestsExceededException, __BaseException>);
 }
 
-export interface MultipleRepositoriesInPullRequestException extends __SmithyException, $MetadataBearer {
-    name: "MultipleRepositoriesInPullRequestException";
-    $fault: "client";
+export declare class MultipleRepositoriesInPullRequestException extends __BaseException {
+    readonly name: "MultipleRepositoriesInPullRequestException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MultipleRepositoriesInPullRequestException, __BaseException>);
 }
 
-export interface ReferenceDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "ReferenceDoesNotExistException";
-    $fault: "client";
+export declare class ReferenceDoesNotExistException extends __BaseException {
+    readonly name: "ReferenceDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ReferenceDoesNotExistException, __BaseException>);
 }
 
-export interface ReferenceNameRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ReferenceNameRequiredException";
-    $fault: "client";
+export declare class ReferenceNameRequiredException extends __BaseException {
+    readonly name: "ReferenceNameRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ReferenceNameRequiredException, __BaseException>);
 }
 
-export interface ReferenceTypeNotSupportedException extends __SmithyException, $MetadataBearer {
-    name: "ReferenceTypeNotSupportedException";
-    $fault: "client";
+export declare class ReferenceTypeNotSupportedException extends __BaseException {
+    readonly name: "ReferenceTypeNotSupportedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ReferenceTypeNotSupportedException, __BaseException>);
 }
 
-export interface SourceAndDestinationAreSameException extends __SmithyException, $MetadataBearer {
-    name: "SourceAndDestinationAreSameException";
-    $fault: "client";
+export declare class SourceAndDestinationAreSameException extends __BaseException {
+    readonly name: "SourceAndDestinationAreSameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<SourceAndDestinationAreSameException, __BaseException>);
 }
 
-export interface TargetRequiredException extends __SmithyException, $MetadataBearer {
-    name: "TargetRequiredException";
-    $fault: "client";
+export declare class TargetRequiredException extends __BaseException {
+    readonly name: "TargetRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TargetRequiredException, __BaseException>);
 }
 
-export interface TargetsRequiredException extends __SmithyException, $MetadataBearer {
-    name: "TargetsRequiredException";
-    $fault: "client";
+export declare class TargetsRequiredException extends __BaseException {
+    readonly name: "TargetsRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TargetsRequiredException, __BaseException>);
 }
 
-export interface TitleRequiredException extends __SmithyException, $MetadataBearer {
-    name: "TitleRequiredException";
-    $fault: "client";
+export declare class TitleRequiredException extends __BaseException {
+    readonly name: "TitleRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TitleRequiredException, __BaseException>);
 }
 export interface CreatePullRequestApprovalRuleInput {
     
@@ -1479,53 +1480,53 @@ export declare namespace CreatePullRequestApprovalRuleOutput {
     const filterSensitiveLog: (obj: CreatePullRequestApprovalRuleOutput) => any;
 }
 
-export interface InvalidApprovalRuleContentException extends __SmithyException, $MetadataBearer {
-    name: "InvalidApprovalRuleContentException";
-    $fault: "client";
+export declare class InvalidApprovalRuleContentException extends __BaseException {
+    readonly name: "InvalidApprovalRuleContentException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleContentException, __BaseException>);
 }
 
-export interface InvalidApprovalRuleNameException extends __SmithyException, $MetadataBearer {
-    name: "InvalidApprovalRuleNameException";
-    $fault: "client";
+export declare class InvalidApprovalRuleNameException extends __BaseException {
+    readonly name: "InvalidApprovalRuleNameException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleNameException, __BaseException>);
 }
 
-export interface InvalidPullRequestIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidPullRequestIdException";
-    $fault: "client";
+export declare class InvalidPullRequestIdException extends __BaseException {
+    readonly name: "InvalidPullRequestIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestIdException, __BaseException>);
 }
 
-export interface NumberOfRulesExceededException extends __SmithyException, $MetadataBearer {
-    name: "NumberOfRulesExceededException";
-    $fault: "client";
+export declare class NumberOfRulesExceededException extends __BaseException {
+    readonly name: "NumberOfRulesExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<NumberOfRulesExceededException, __BaseException>);
 }
 
-export interface PullRequestAlreadyClosedException extends __SmithyException, $MetadataBearer {
-    name: "PullRequestAlreadyClosedException";
-    $fault: "client";
+export declare class PullRequestAlreadyClosedException extends __BaseException {
+    readonly name: "PullRequestAlreadyClosedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PullRequestAlreadyClosedException, __BaseException>);
 }
 
-export interface PullRequestDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "PullRequestDoesNotExistException";
-    $fault: "client";
+export declare class PullRequestDoesNotExistException extends __BaseException {
+    readonly name: "PullRequestDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PullRequestDoesNotExistException, __BaseException>);
 }
 
-export interface PullRequestIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "PullRequestIdRequiredException";
-    $fault: "client";
+export declare class PullRequestIdRequiredException extends __BaseException {
+    readonly name: "PullRequestIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PullRequestIdRequiredException, __BaseException>);
 }
 
 export interface CreateRepositoryInput {
@@ -1552,60 +1553,60 @@ export declare namespace CreateRepositoryOutput {
     const filterSensitiveLog: (obj: CreateRepositoryOutput) => any;
 }
 
-export interface InvalidRepositoryDescriptionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidRepositoryDescriptionException";
-    $fault: "client";
+export declare class InvalidRepositoryDescriptionException extends __BaseException {
+    readonly name: "InvalidRepositoryDescriptionException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidRepositoryDescriptionException, __BaseException>);
 }
 
-export interface InvalidSystemTagUsageException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSystemTagUsageException";
-    $fault: "client";
+export declare class InvalidSystemTagUsageException extends __BaseException {
+    readonly name: "InvalidSystemTagUsageException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidSystemTagUsageException, __BaseException>);
 }
 
-export interface InvalidTagsMapException extends __SmithyException, $MetadataBearer {
-    name: "InvalidTagsMapException";
-    $fault: "client";
+export declare class InvalidTagsMapException extends __BaseException {
+    readonly name: "InvalidTagsMapException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidTagsMapException, __BaseException>);
 }
 
-export interface RepositoryLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryLimitExceededException";
-    $fault: "client";
+export declare class RepositoryLimitExceededException extends __BaseException {
+    readonly name: "RepositoryLimitExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryLimitExceededException, __BaseException>);
 }
 
-export interface RepositoryNameExistsException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryNameExistsException";
-    $fault: "client";
+export declare class RepositoryNameExistsException extends __BaseException {
+    readonly name: "RepositoryNameExistsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryNameExistsException, __BaseException>);
 }
 
-export interface TagPolicyException extends __SmithyException, $MetadataBearer {
-    name: "TagPolicyException";
-    $fault: "client";
+export declare class TagPolicyException extends __BaseException {
+    readonly name: "TagPolicyException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TagPolicyException, __BaseException>);
 }
 
-export interface TooManyTagsException extends __SmithyException, $MetadataBearer {
-    name: "TooManyTagsException";
-    $fault: "client";
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
 }
 
-export interface ConcurrentReferenceUpdateException extends __SmithyException, $MetadataBearer {
-    name: "ConcurrentReferenceUpdateException";
-    $fault: "client";
+export declare class ConcurrentReferenceUpdateException extends __BaseException {
+    readonly name: "ConcurrentReferenceUpdateException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ConcurrentReferenceUpdateException, __BaseException>);
 }
 export declare enum ReplacementTypeEnum {
     KEEP_BASE = "KEEP_BASE",
@@ -1680,60 +1681,60 @@ export declare namespace CreateUnreferencedMergeCommitOutput {
     const filterSensitiveLog: (obj: CreateUnreferencedMergeCommitOutput) => any;
 }
 
-export interface InvalidConflictResolutionException extends __SmithyException, $MetadataBearer {
-    name: "InvalidConflictResolutionException";
-    $fault: "client";
+export declare class InvalidConflictResolutionException extends __BaseException {
+    readonly name: "InvalidConflictResolutionException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidConflictResolutionException, __BaseException>);
 }
 
-export interface InvalidReplacementContentException extends __SmithyException, $MetadataBearer {
-    name: "InvalidReplacementContentException";
-    $fault: "client";
+export declare class InvalidReplacementContentException extends __BaseException {
+    readonly name: "InvalidReplacementContentException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidReplacementContentException, __BaseException>);
 }
 
-export interface InvalidReplacementTypeException extends __SmithyException, $MetadataBearer {
-    name: "InvalidReplacementTypeException";
-    $fault: "client";
+export declare class InvalidReplacementTypeException extends __BaseException {
+    readonly name: "InvalidReplacementTypeException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidReplacementTypeException, __BaseException>);
 }
 
-export interface ManualMergeRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ManualMergeRequiredException";
-    $fault: "client";
+export declare class ManualMergeRequiredException extends __BaseException {
+    readonly name: "ManualMergeRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ManualMergeRequiredException, __BaseException>);
 }
 
-export interface MaximumConflictResolutionEntriesExceededException extends __SmithyException, $MetadataBearer {
-    name: "MaximumConflictResolutionEntriesExceededException";
-    $fault: "client";
+export declare class MaximumConflictResolutionEntriesExceededException extends __BaseException {
+    readonly name: "MaximumConflictResolutionEntriesExceededException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MaximumConflictResolutionEntriesExceededException, __BaseException>);
 }
 
-export interface MultipleConflictResolutionEntriesException extends __SmithyException, $MetadataBearer {
-    name: "MultipleConflictResolutionEntriesException";
-    $fault: "client";
+export declare class MultipleConflictResolutionEntriesException extends __BaseException {
+    readonly name: "MultipleConflictResolutionEntriesException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<MultipleConflictResolutionEntriesException, __BaseException>);
 }
 
-export interface ReplacementContentRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ReplacementContentRequiredException";
-    $fault: "client";
+export declare class ReplacementContentRequiredException extends __BaseException {
+    readonly name: "ReplacementContentRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ReplacementContentRequiredException, __BaseException>);
 }
 
-export interface ReplacementTypeRequiredException extends __SmithyException, $MetadataBearer {
-    name: "ReplacementTypeRequiredException";
-    $fault: "client";
+export declare class ReplacementTypeRequiredException extends __BaseException {
+    readonly name: "ReplacementTypeRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<ReplacementTypeRequiredException, __BaseException>);
 }
 export interface DeleteApprovalRuleTemplateInput {
     
@@ -1752,11 +1753,11 @@ export declare namespace DeleteApprovalRuleTemplateOutput {
     const filterSensitiveLog: (obj: DeleteApprovalRuleTemplateOutput) => any;
 }
 
-export interface DefaultBranchCannotBeDeletedException extends __SmithyException, $MetadataBearer {
-    name: "DefaultBranchCannotBeDeletedException";
-    $fault: "client";
+export declare class DefaultBranchCannotBeDeletedException extends __BaseException {
+    readonly name: "DefaultBranchCannotBeDeletedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<DefaultBranchCannotBeDeletedException, __BaseException>);
 }
 
 export interface DeleteBranchInput {
@@ -1779,25 +1780,25 @@ export declare namespace DeleteBranchOutput {
     const filterSensitiveLog: (obj: DeleteBranchOutput) => any;
 }
 
-export interface CommentDeletedException extends __SmithyException, $MetadataBearer {
-    name: "CommentDeletedException";
-    $fault: "client";
+export declare class CommentDeletedException extends __BaseException {
+    readonly name: "CommentDeletedException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommentDeletedException, __BaseException>);
 }
 
-export interface CommentDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "CommentDoesNotExistException";
-    $fault: "client";
+export declare class CommentDoesNotExistException extends __BaseException {
+    readonly name: "CommentDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommentDoesNotExistException, __BaseException>);
 }
 
-export interface CommentIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "CommentIdRequiredException";
-    $fault: "client";
+export declare class CommentIdRequiredException extends __BaseException {
+    readonly name: "CommentIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommentIdRequiredException, __BaseException>);
 }
 export interface DeleteCommentContentInput {
     
@@ -1845,11 +1846,11 @@ export declare namespace DeleteCommentContentOutput {
     const filterSensitiveLog: (obj: DeleteCommentContentOutput) => any;
 }
 
-export interface InvalidCommentIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidCommentIdException";
-    $fault: "client";
+export declare class InvalidCommentIdException extends __BaseException {
+    readonly name: "InvalidCommentIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidCommentIdException, __BaseException>);
 }
 export interface DeleteFileInput {
     
@@ -2084,25 +2085,25 @@ export declare namespace DescribePullRequestEventsOutput {
     const filterSensitiveLog: (obj: DescribePullRequestEventsOutput) => any;
 }
 
-export interface InvalidActorArnException extends __SmithyException, $MetadataBearer {
-    name: "InvalidActorArnException";
-    $fault: "client";
+export declare class InvalidActorArnException extends __BaseException {
+    readonly name: "InvalidActorArnException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidActorArnException, __BaseException>);
 }
 
-export interface InvalidMaxResultsException extends __SmithyException, $MetadataBearer {
-    name: "InvalidMaxResultsException";
-    $fault: "client";
+export declare class InvalidMaxResultsException extends __BaseException {
+    readonly name: "InvalidMaxResultsException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidMaxResultsException, __BaseException>);
 }
 
-export interface InvalidPullRequestEventTypeException extends __SmithyException, $MetadataBearer {
-    name: "InvalidPullRequestEventTypeException";
-    $fault: "client";
+export declare class InvalidPullRequestEventTypeException extends __BaseException {
+    readonly name: "InvalidPullRequestEventTypeException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestEventTypeException, __BaseException>);
 }
 export interface DisassociateApprovalRuleTemplateFromRepositoryInput {
     
@@ -2148,25 +2149,25 @@ export declare namespace EvaluatePullRequestApprovalRulesOutput {
     const filterSensitiveLog: (obj: EvaluatePullRequestApprovalRulesOutput) => any;
 }
 
-export interface InvalidRevisionIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidRevisionIdException";
-    $fault: "client";
+export declare class InvalidRevisionIdException extends __BaseException {
+    readonly name: "InvalidRevisionIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidRevisionIdException, __BaseException>);
 }
 
-export interface RevisionIdRequiredException extends __SmithyException, $MetadataBearer {
-    name: "RevisionIdRequiredException";
-    $fault: "client";
+export declare class RevisionIdRequiredException extends __BaseException {
+    readonly name: "RevisionIdRequiredException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RevisionIdRequiredException, __BaseException>);
 }
 
-export interface RevisionNotCurrentException extends __SmithyException, $MetadataBearer {
-    name: "RevisionNotCurrentException";
-    $fault: "client";
+export declare class RevisionNotCurrentException extends __BaseException {
+    readonly name: "RevisionNotCurrentException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RevisionNotCurrentException, __BaseException>);
 }
 export interface GetApprovalRuleTemplateInput {
     
@@ -2185,11 +2186,11 @@ export declare namespace GetApprovalRuleTemplateOutput {
     const filterSensitiveLog: (obj: GetApprovalRuleTemplateOutput) => any;
 }
 
-export interface FileTooLargeException extends __SmithyException, $MetadataBearer {
-    name: "FileTooLargeException";
-    $fault: "client";
+export declare class FileTooLargeException extends __BaseException {
+    readonly name: "FileTooLargeException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FileTooLargeException, __BaseException>);
 }
 
 export interface GetBlobInput {
@@ -2212,11 +2213,11 @@ export declare namespace GetBlobOutput {
     const filterSensitiveLog: (obj: GetBlobOutput) => any;
 }
 
-export interface InvalidBlobIdException extends __SmithyException, $MetadataBearer {
-    name: "InvalidBlobIdException";
-    $fault: "client";
+export declare class InvalidBlobIdException extends __BaseException {
+    readonly name: "InvalidBlobIdException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidBlobIdException, __BaseException>);
 }
 
 export interface GetBranchInput {
@@ -2305,11 +2306,11 @@ export declare namespace GetCommentReactionsOutput {
     const filterSensitiveLog: (obj: GetCommentReactionsOutput) => any;
 }
 
-export interface InvalidReactionUserArnException extends __SmithyException, $MetadataBearer {
-    name: "InvalidReactionUserArnException";
-    $fault: "client";
+export declare class InvalidReactionUserArnException extends __BaseException {
+    readonly name: "InvalidReactionUserArnException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidReactionUserArnException, __BaseException>);
 }
 export interface GetCommentsForComparedCommitInput {
     
@@ -2427,18 +2428,18 @@ export declare namespace GetCommentsForPullRequestOutput {
     const filterSensitiveLog: (obj: GetCommentsForPullRequestOutput) => any;
 }
 
-export interface RepositoryNotAssociatedWithPullRequestException extends __SmithyException, $MetadataBearer {
-    name: "RepositoryNotAssociatedWithPullRequestException";
-    $fault: "client";
+export declare class RepositoryNotAssociatedWithPullRequestException extends __BaseException {
+    readonly name: "RepositoryNotAssociatedWithPullRequestException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<RepositoryNotAssociatedWithPullRequestException, __BaseException>);
 }
 
-export interface CommitIdDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "CommitIdDoesNotExistException";
-    $fault: "client";
+export declare class CommitIdDoesNotExistException extends __BaseException {
+    readonly name: "CommitIdDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<CommitIdDoesNotExistException, __BaseException>);
 }
 
 export interface GetCommitInput {
@@ -2504,11 +2505,11 @@ export declare namespace GetDifferencesOutput {
     const filterSensitiveLog: (obj: GetDifferencesOutput) => any;
 }
 
-export interface PathDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "PathDoesNotExistException";
-    $fault: "client";
+export declare class PathDoesNotExistException extends __BaseException {
+    readonly name: "PathDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<PathDoesNotExistException, __BaseException>);
 }
 export interface GetFileInput {
     
@@ -2541,11 +2542,11 @@ export declare namespace GetFileOutput {
     const filterSensitiveLog: (obj: GetFileOutput) => any;
 }
 
-export interface FolderDoesNotExistException extends __SmithyException, $MetadataBearer {
-    name: "FolderDoesNotExistException";
-    $fault: "client";
+export declare class FolderDoesNotExistException extends __BaseException {
+    readonly name: "FolderDoesNotExistException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<FolderDoesNotExistException, __BaseException>);
 }
 export interface GetFolderInput {
     
@@ -2706,18 +2707,18 @@ export declare namespace GetMergeConflictsOutput {
     const filterSensitiveLog: (obj: GetMergeConflictsOutput) => any;
 }
 
-export interface InvalidDestinationCommitSpecifierException extends __SmithyException, $MetadataBearer {
-    name: "InvalidDestinationCommitSpecifierException";
-    $fault: "client";
+export declare class InvalidDestinationCommitSpecifierException extends __BaseException {
+    readonly name: "InvalidDestinationCommitSpecifierException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidDestinationCommitSpecifierException, __BaseException>);
 }
 
-export interface InvalidSourceCommitSpecifierException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSourceCommitSpecifierException";
-    $fault: "client";
+export declare class InvalidSourceCommitSpecifierException extends __BaseException {
+    readonly name: "InvalidSourceCommitSpecifierException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidSourceCommitSpecifierException, __BaseException>);
 }
 export interface GetMergeOptionsInput {
     
@@ -2929,18 +2930,18 @@ export declare namespace ListBranchesOutput {
     const filterSensitiveLog: (obj: ListBranchesOutput) => any;
 }
 
-export interface InvalidAuthorArnException extends __SmithyException, $MetadataBearer {
-    name: "InvalidAuthorArnException";
-    $fault: "client";
+export declare class InvalidAuthorArnException extends __BaseException {
+    readonly name: "InvalidAuthorArnException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidAuthorArnException, __BaseException>);
 }
 
-export interface InvalidPullRequestStatusException extends __SmithyException, $MetadataBearer {
-    name: "InvalidPullRequestStatusException";
-    $fault: "client";
+export declare class InvalidPullRequestStatusException extends __BaseException {
+    readonly name: "InvalidPullRequestStatusException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestStatusException, __BaseException>);
 }
 export interface ListPullRequestsInput {
     
@@ -2969,16 +2970,16 @@ export declare namespace ListPullRequestsOutput {
     const filterSensitiveLog: (obj: ListPullRequestsOutput) => any;
 }
 
-export interface InvalidOrderException extends __SmithyException, $MetadataBearer {
-    name: "InvalidOrderException";
-    $fault: "client";
+export declare class InvalidOrderException extends __BaseException {
+    readonly name: "InvalidOrderException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidOrderException, __BaseException>);
 }
 
-export interface InvalidSortByException extends __SmithyException, $MetadataBearer {
-    name: "InvalidSortByException";
-    $fault: "client";
+export declare class InvalidSortByException extends __BaseException {
+    readonly name: "InvalidSortByException";
+    readonly $fault: "client";
     
-    message?: string;
+    constructor(opts: __ExceptionOptionType<InvalidSortByException, __BaseException>);
 }