@aws-sdk/client-codecommit 3.50.0 → 3.53.0

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

@@ -0,0 +1,2985 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CodeCommitServiceException as __BaseException } from "./CodeCommitServiceException";
+
+export declare class ActorDoesNotExistException extends __BaseException {
+    readonly name: "ActorDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ActorDoesNotExistException, __BaseException>);
+}
+export declare enum ApprovalState {
+    APPROVE = "APPROVE",
+    REVOKE = "REVOKE"
+}
+
+export interface Approval {
+    
+    userArn?: string;
+    
+    approvalState?: ApprovalState | string;
+}
+export declare namespace Approval {
+    
+    const filterSensitiveLog: (obj: Approval) => any;
+}
+
+export interface OriginApprovalRuleTemplate {
+    
+    approvalRuleTemplateId?: string;
+    
+    approvalRuleTemplateName?: string;
+}
+export declare namespace OriginApprovalRuleTemplate {
+    
+    const filterSensitiveLog: (obj: OriginApprovalRuleTemplate) => any;
+}
+
+export interface ApprovalRule {
+    
+    approvalRuleId?: string;
+    
+    approvalRuleName?: string;
+    
+    approvalRuleContent?: string;
+    
+    ruleContentSha256?: string;
+    
+    lastModifiedDate?: Date;
+    
+    creationDate?: Date;
+    
+    lastModifiedUser?: string;
+    
+    originApprovalRuleTemplate?: OriginApprovalRuleTemplate;
+}
+export declare namespace ApprovalRule {
+    
+    const filterSensitiveLog: (obj: ApprovalRule) => any;
+}
+
+export declare class ApprovalRuleContentRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleContentRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleContentRequiredException, __BaseException>);
+}
+
+export declare class ApprovalRuleDoesNotExistException extends __BaseException {
+    readonly name: "ApprovalRuleDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleDoesNotExistException, __BaseException>);
+}
+
+export interface ApprovalRuleEventMetadata {
+    
+    approvalRuleName?: string;
+    
+    approvalRuleId?: string;
+    
+    approvalRuleContent?: string;
+}
+export declare namespace ApprovalRuleEventMetadata {
+    
+    const filterSensitiveLog: (obj: ApprovalRuleEventMetadata) => any;
+}
+
+export declare class ApprovalRuleNameAlreadyExistsException extends __BaseException {
+    readonly name: "ApprovalRuleNameAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleNameAlreadyExistsException, __BaseException>);
+}
+
+export declare class ApprovalRuleNameRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleNameRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleNameRequiredException, __BaseException>);
+}
+export declare enum OverrideStatus {
+    OVERRIDE = "OVERRIDE",
+    REVOKE = "REVOKE"
+}
+
+export interface ApprovalRuleOverriddenEventMetadata {
+    
+    revisionId?: string;
+    
+    overrideStatus?: OverrideStatus | string;
+}
+export declare namespace ApprovalRuleOverriddenEventMetadata {
+    
+    const filterSensitiveLog: (obj: ApprovalRuleOverriddenEventMetadata) => any;
+}
+
+export interface ApprovalRuleTemplate {
+    
+    approvalRuleTemplateId?: string;
+    
+    approvalRuleTemplateName?: string;
+    
+    approvalRuleTemplateDescription?: string;
+    
+    approvalRuleTemplateContent?: string;
+    
+    ruleContentSha256?: string;
+    
+    lastModifiedDate?: Date;
+    
+    creationDate?: Date;
+    
+    lastModifiedUser?: string;
+}
+export declare namespace ApprovalRuleTemplate {
+    
+    const filterSensitiveLog: (obj: ApprovalRuleTemplate) => any;
+}
+
+export declare class ApprovalRuleTemplateContentRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateContentRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateContentRequiredException, __BaseException>);
+}
+
+export declare class ApprovalRuleTemplateDoesNotExistException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateDoesNotExistException, __BaseException>);
+}
+
+export declare class ApprovalRuleTemplateInUseException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateInUseException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateInUseException, __BaseException>);
+}
+
+export declare class ApprovalRuleTemplateNameAlreadyExistsException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateNameAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateNameAlreadyExistsException, __BaseException>);
+}
+
+export declare class ApprovalRuleTemplateNameRequiredException extends __BaseException {
+    readonly name: "ApprovalRuleTemplateNameRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalRuleTemplateNameRequiredException, __BaseException>);
+}
+
+export interface ApprovalStateChangedEventMetadata {
+    
+    revisionId?: string;
+    
+    approvalStatus?: ApprovalState | string;
+}
+export declare namespace ApprovalStateChangedEventMetadata {
+    
+    const filterSensitiveLog: (obj: ApprovalStateChangedEventMetadata) => any;
+}
+
+export declare class ApprovalStateRequiredException extends __BaseException {
+    readonly name: "ApprovalStateRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ApprovalStateRequiredException, __BaseException>);
+}
+export interface AssociateApprovalRuleTemplateWithRepositoryInput {
+    
+    approvalRuleTemplateName: string | undefined;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace AssociateApprovalRuleTemplateWithRepositoryInput {
+    
+    const filterSensitiveLog: (obj: AssociateApprovalRuleTemplateWithRepositoryInput) => any;
+}
+
+export declare class EncryptionIntegrityChecksFailedException extends __BaseException {
+    readonly name: "EncryptionIntegrityChecksFailedException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<EncryptionIntegrityChecksFailedException, __BaseException>);
+}
+
+export declare class EncryptionKeyAccessDeniedException extends __BaseException {
+    readonly name: "EncryptionKeyAccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EncryptionKeyAccessDeniedException, __BaseException>);
+}
+
+export declare class EncryptionKeyDisabledException extends __BaseException {
+    readonly name: "EncryptionKeyDisabledException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EncryptionKeyDisabledException, __BaseException>);
+}
+
+export declare class EncryptionKeyNotFoundException extends __BaseException {
+    readonly name: "EncryptionKeyNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EncryptionKeyNotFoundException, __BaseException>);
+}
+
+export declare class EncryptionKeyUnavailableException extends __BaseException {
+    readonly name: "EncryptionKeyUnavailableException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<EncryptionKeyUnavailableException, __BaseException>);
+}
+
+export declare class InvalidApprovalRuleTemplateNameException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateNameException, __BaseException>);
+}
+
+export declare class InvalidRepositoryNameException extends __BaseException {
+    readonly name: "InvalidRepositoryNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRepositoryNameException, __BaseException>);
+}
+
+export declare class MaximumRuleTemplatesAssociatedWithRepositoryException extends __BaseException {
+    readonly name: "MaximumRuleTemplatesAssociatedWithRepositoryException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumRuleTemplatesAssociatedWithRepositoryException, __BaseException>);
+}
+
+export declare class RepositoryDoesNotExistException extends __BaseException {
+    readonly name: "RepositoryDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryDoesNotExistException, __BaseException>);
+}
+
+export declare class RepositoryNameRequiredException extends __BaseException {
+    readonly name: "RepositoryNameRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryNameRequiredException, __BaseException>);
+}
+
+export declare class AuthorDoesNotExistException extends __BaseException {
+    readonly name: "AuthorDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AuthorDoesNotExistException, __BaseException>);
+}
+export interface BatchAssociateApprovalRuleTemplateWithRepositoriesInput {
+    
+    approvalRuleTemplateName: string | undefined;
+    
+    repositoryNames: string[] | undefined;
+}
+export declare namespace BatchAssociateApprovalRuleTemplateWithRepositoriesInput {
+    
+    const filterSensitiveLog: (obj: BatchAssociateApprovalRuleTemplateWithRepositoriesInput) => any;
+}
+
+export interface BatchAssociateApprovalRuleTemplateWithRepositoriesError {
+    
+    repositoryName?: string;
+    
+    errorCode?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace BatchAssociateApprovalRuleTemplateWithRepositoriesError {
+    
+    const filterSensitiveLog: (obj: BatchAssociateApprovalRuleTemplateWithRepositoriesError) => any;
+}
+export interface BatchAssociateApprovalRuleTemplateWithRepositoriesOutput {
+    
+    associatedRepositoryNames: string[] | undefined;
+    
+    errors: BatchAssociateApprovalRuleTemplateWithRepositoriesError[] | undefined;
+}
+export declare namespace BatchAssociateApprovalRuleTemplateWithRepositoriesOutput {
+    
+    const filterSensitiveLog: (obj: BatchAssociateApprovalRuleTemplateWithRepositoriesOutput) => any;
+}
+
+export declare class MaximumRepositoryNamesExceededException extends __BaseException {
+    readonly name: "MaximumRepositoryNamesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumRepositoryNamesExceededException, __BaseException>);
+}
+
+export declare class RepositoryNamesRequiredException extends __BaseException {
+    readonly name: "RepositoryNamesRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryNamesRequiredException, __BaseException>);
+}
+export declare enum ConflictDetailLevelTypeEnum {
+    FILE_LEVEL = "FILE_LEVEL",
+    LINE_LEVEL = "LINE_LEVEL"
+}
+export declare enum ConflictResolutionStrategyTypeEnum {
+    ACCEPT_DESTINATION = "ACCEPT_DESTINATION",
+    ACCEPT_SOURCE = "ACCEPT_SOURCE",
+    AUTOMERGE = "AUTOMERGE",
+    NONE = "NONE"
+}
+export declare enum MergeOptionTypeEnum {
+    FAST_FORWARD_MERGE = "FAST_FORWARD_MERGE",
+    SQUASH_MERGE = "SQUASH_MERGE",
+    THREE_WAY_MERGE = "THREE_WAY_MERGE"
+}
+export interface BatchDescribeMergeConflictsInput {
+    
+    repositoryName: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    mergeOption: MergeOptionTypeEnum | string | undefined;
+    
+    maxMergeHunks?: number;
+    
+    maxConflictFiles?: number;
+    
+    filePaths?: string[];
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+    
+    nextToken?: string;
+}
+export declare namespace BatchDescribeMergeConflictsInput {
+    
+    const filterSensitiveLog: (obj: BatchDescribeMergeConflictsInput) => any;
+}
+export declare enum FileModeTypeEnum {
+    EXECUTABLE = "EXECUTABLE",
+    NORMAL = "NORMAL",
+    SYMLINK = "SYMLINK"
+}
+
+export interface FileModes {
+    
+    source?: FileModeTypeEnum | string;
+    
+    destination?: FileModeTypeEnum | string;
+    
+    base?: FileModeTypeEnum | string;
+}
+export declare namespace FileModes {
+    
+    const filterSensitiveLog: (obj: FileModes) => any;
+}
+
+export interface FileSizes {
+    
+    source?: number;
+    
+    destination?: number;
+    
+    base?: number;
+}
+export declare namespace FileSizes {
+    
+    const filterSensitiveLog: (obj: FileSizes) => any;
+}
+
+export interface IsBinaryFile {
+    
+    source?: boolean;
+    
+    destination?: boolean;
+    
+    base?: boolean;
+}
+export declare namespace IsBinaryFile {
+    
+    const filterSensitiveLog: (obj: IsBinaryFile) => any;
+}
+export declare enum ChangeTypeEnum {
+    ADDED = "A",
+    DELETED = "D",
+    MODIFIED = "M"
+}
+
+export interface MergeOperations {
+    
+    source?: ChangeTypeEnum | string;
+    
+    destination?: ChangeTypeEnum | string;
+}
+export declare namespace MergeOperations {
+    
+    const filterSensitiveLog: (obj: MergeOperations) => any;
+}
+export declare enum ObjectTypeEnum {
+    DIRECTORY = "DIRECTORY",
+    FILE = "FILE",
+    GIT_LINK = "GIT_LINK",
+    SYMBOLIC_LINK = "SYMBOLIC_LINK"
+}
+
+export interface ObjectTypes {
+    
+    source?: ObjectTypeEnum | string;
+    
+    destination?: ObjectTypeEnum | string;
+    
+    base?: ObjectTypeEnum | string;
+}
+export declare namespace ObjectTypes {
+    
+    const filterSensitiveLog: (obj: ObjectTypes) => any;
+}
+
+export interface ConflictMetadata {
+    
+    filePath?: string;
+    
+    fileSizes?: FileSizes;
+    
+    fileModes?: FileModes;
+    
+    objectTypes?: ObjectTypes;
+    
+    numberOfConflicts?: number;
+    
+    isBinaryFile?: IsBinaryFile;
+    
+    contentConflict?: boolean;
+    
+    fileModeConflict?: boolean;
+    
+    objectTypeConflict?: boolean;
+    
+    mergeOperations?: MergeOperations;
+}
+export declare namespace ConflictMetadata {
+    
+    const filterSensitiveLog: (obj: ConflictMetadata) => any;
+}
+
+export interface MergeHunkDetail {
+    
+    startLine?: number;
+    
+    endLine?: number;
+    
+    hunkContent?: string;
+}
+export declare namespace MergeHunkDetail {
+    
+    const filterSensitiveLog: (obj: MergeHunkDetail) => any;
+}
+
+export interface MergeHunk {
+    
+    isConflict?: boolean;
+    
+    source?: MergeHunkDetail;
+    
+    destination?: MergeHunkDetail;
+    
+    base?: MergeHunkDetail;
+}
+export declare namespace MergeHunk {
+    
+    const filterSensitiveLog: (obj: MergeHunk) => any;
+}
+
+export interface Conflict {
+    
+    conflictMetadata?: ConflictMetadata;
+    
+    mergeHunks?: MergeHunk[];
+}
+export declare namespace Conflict {
+    
+    const filterSensitiveLog: (obj: Conflict) => any;
+}
+
+export interface BatchDescribeMergeConflictsError {
+    
+    filePath: string | undefined;
+    
+    exceptionName: string | undefined;
+    
+    message: string | undefined;
+}
+export declare namespace BatchDescribeMergeConflictsError {
+    
+    const filterSensitiveLog: (obj: BatchDescribeMergeConflictsError) => any;
+}
+export interface BatchDescribeMergeConflictsOutput {
+    
+    conflicts: Conflict[] | undefined;
+    
+    nextToken?: string;
+    
+    errors?: BatchDescribeMergeConflictsError[];
+    
+    destinationCommitId: string | undefined;
+    
+    sourceCommitId: string | undefined;
+    
+    baseCommitId?: string;
+}
+export declare namespace BatchDescribeMergeConflictsOutput {
+    
+    const filterSensitiveLog: (obj: BatchDescribeMergeConflictsOutput) => any;
+}
+
+export declare class CommitDoesNotExistException extends __BaseException {
+    readonly name: "CommitDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitDoesNotExistException, __BaseException>);
+}
+
+export declare class CommitRequiredException extends __BaseException {
+    readonly name: "CommitRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitRequiredException, __BaseException>);
+}
+
+export declare class InvalidCommitException extends __BaseException {
+    readonly name: "InvalidCommitException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidCommitException, __BaseException>);
+}
+
+export declare class InvalidConflictDetailLevelException extends __BaseException {
+    readonly name: "InvalidConflictDetailLevelException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidConflictDetailLevelException, __BaseException>);
+}
+
+export declare class InvalidConflictResolutionStrategyException extends __BaseException {
+    readonly name: "InvalidConflictResolutionStrategyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidConflictResolutionStrategyException, __BaseException>);
+}
+
+export declare class InvalidContinuationTokenException extends __BaseException {
+    readonly name: "InvalidContinuationTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidContinuationTokenException, __BaseException>);
+}
+
+export declare class InvalidMaxConflictFilesException extends __BaseException {
+    readonly name: "InvalidMaxConflictFilesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidMaxConflictFilesException, __BaseException>);
+}
+
+export declare class InvalidMaxMergeHunksException extends __BaseException {
+    readonly name: "InvalidMaxMergeHunksException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidMaxMergeHunksException, __BaseException>);
+}
+
+export declare class InvalidMergeOptionException extends __BaseException {
+    readonly name: "InvalidMergeOptionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidMergeOptionException, __BaseException>);
+}
+
+export declare class MaximumFileContentToLoadExceededException extends __BaseException {
+    readonly name: "MaximumFileContentToLoadExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumFileContentToLoadExceededException, __BaseException>);
+}
+
+export declare class MaximumItemsToCompareExceededException extends __BaseException {
+    readonly name: "MaximumItemsToCompareExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumItemsToCompareExceededException, __BaseException>);
+}
+
+export declare class MergeOptionRequiredException extends __BaseException {
+    readonly name: "MergeOptionRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MergeOptionRequiredException, __BaseException>);
+}
+
+export declare class TipsDivergenceExceededException extends __BaseException {
+    readonly name: "TipsDivergenceExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TipsDivergenceExceededException, __BaseException>);
+}
+export interface BatchDisassociateApprovalRuleTemplateFromRepositoriesInput {
+    
+    approvalRuleTemplateName: string | undefined;
+    
+    repositoryNames: string[] | undefined;
+}
+export declare namespace BatchDisassociateApprovalRuleTemplateFromRepositoriesInput {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateApprovalRuleTemplateFromRepositoriesInput) => any;
+}
+
+export interface BatchDisassociateApprovalRuleTemplateFromRepositoriesError {
+    
+    repositoryName?: string;
+    
+    errorCode?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace BatchDisassociateApprovalRuleTemplateFromRepositoriesError {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateApprovalRuleTemplateFromRepositoriesError) => any;
+}
+export interface BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput {
+    
+    disassociatedRepositoryNames: string[] | undefined;
+    
+    errors: BatchDisassociateApprovalRuleTemplateFromRepositoriesError[] | undefined;
+}
+export declare namespace BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput) => any;
+}
+export interface BatchGetCommitsInput {
+    
+    commitIds: string[] | undefined;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace BatchGetCommitsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetCommitsInput) => any;
+}
+
+export interface UserInfo {
+    
+    name?: string;
+    
+    email?: string;
+    
+    date?: string;
+}
+export declare namespace UserInfo {
+    
+    const filterSensitiveLog: (obj: UserInfo) => any;
+}
+
+export interface Commit {
+    
+    commitId?: string;
+    
+    treeId?: string;
+    
+    parents?: string[];
+    
+    message?: string;
+    
+    author?: UserInfo;
+    
+    committer?: UserInfo;
+    
+    additionalData?: string;
+}
+export declare namespace Commit {
+    
+    const filterSensitiveLog: (obj: Commit) => any;
+}
+
+export interface BatchGetCommitsError {
+    
+    commitId?: string;
+    
+    errorCode?: string;
+    
+    errorMessage?: string;
+}
+export declare namespace BatchGetCommitsError {
+    
+    const filterSensitiveLog: (obj: BatchGetCommitsError) => any;
+}
+export interface BatchGetCommitsOutput {
+    
+    commits?: Commit[];
+    
+    errors?: BatchGetCommitsError[];
+}
+export declare namespace BatchGetCommitsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetCommitsOutput) => any;
+}
+
+export declare class CommitIdsLimitExceededException extends __BaseException {
+    readonly name: "CommitIdsLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitIdsLimitExceededException, __BaseException>);
+}
+
+export declare class CommitIdsListRequiredException extends __BaseException {
+    readonly name: "CommitIdsListRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitIdsListRequiredException, __BaseException>);
+}
+
+export interface BatchGetRepositoriesInput {
+    
+    repositoryNames: string[] | undefined;
+}
+export declare namespace BatchGetRepositoriesInput {
+    
+    const filterSensitiveLog: (obj: BatchGetRepositoriesInput) => any;
+}
+
+export interface RepositoryMetadata {
+    
+    accountId?: string;
+    
+    repositoryId?: string;
+    
+    repositoryName?: string;
+    
+    repositoryDescription?: string;
+    
+    defaultBranch?: string;
+    
+    lastModifiedDate?: Date;
+    
+    creationDate?: Date;
+    
+    cloneUrlHttp?: string;
+    
+    cloneUrlSsh?: string;
+    
+    Arn?: string;
+}
+export declare namespace RepositoryMetadata {
+    
+    const filterSensitiveLog: (obj: RepositoryMetadata) => any;
+}
+
+export interface BatchGetRepositoriesOutput {
+    
+    repositories?: RepositoryMetadata[];
+    
+    repositoriesNotFound?: string[];
+}
+export declare namespace BatchGetRepositoriesOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetRepositoriesOutput) => any;
+}
+
+export declare class BeforeCommitIdAndAfterCommitIdAreSameException extends __BaseException {
+    readonly name: "BeforeCommitIdAndAfterCommitIdAreSameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BeforeCommitIdAndAfterCommitIdAreSameException, __BaseException>);
+}
+
+export declare class BlobIdDoesNotExistException extends __BaseException {
+    readonly name: "BlobIdDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BlobIdDoesNotExistException, __BaseException>);
+}
+
+export declare class BlobIdRequiredException extends __BaseException {
+    readonly name: "BlobIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BlobIdRequiredException, __BaseException>);
+}
+
+export interface BlobMetadata {
+    
+    blobId?: string;
+    
+    path?: string;
+    
+    mode?: string;
+}
+export declare namespace BlobMetadata {
+    
+    const filterSensitiveLog: (obj: BlobMetadata) => any;
+}
+
+export declare class BranchDoesNotExistException extends __BaseException {
+    readonly name: "BranchDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BranchDoesNotExistException, __BaseException>);
+}
+
+export interface BranchInfo {
+    
+    branchName?: string;
+    
+    commitId?: string;
+}
+export declare namespace BranchInfo {
+    
+    const filterSensitiveLog: (obj: BranchInfo) => any;
+}
+
+export declare class BranchNameExistsException extends __BaseException {
+    readonly name: "BranchNameExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BranchNameExistsException, __BaseException>);
+}
+
+export declare class BranchNameIsTagNameException extends __BaseException {
+    readonly name: "BranchNameIsTagNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BranchNameIsTagNameException, __BaseException>);
+}
+
+export declare class BranchNameRequiredException extends __BaseException {
+    readonly name: "BranchNameRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BranchNameRequiredException, __BaseException>);
+}
+
+export declare class CannotDeleteApprovalRuleFromTemplateException extends __BaseException {
+    readonly name: "CannotDeleteApprovalRuleFromTemplateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CannotDeleteApprovalRuleFromTemplateException, __BaseException>);
+}
+
+export declare class CannotModifyApprovalRuleFromTemplateException extends __BaseException {
+    readonly name: "CannotModifyApprovalRuleFromTemplateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CannotModifyApprovalRuleFromTemplateException, __BaseException>);
+}
+
+export declare class ClientRequestTokenRequiredException extends __BaseException {
+    readonly name: "ClientRequestTokenRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ClientRequestTokenRequiredException, __BaseException>);
+}
+export interface CreateApprovalRuleTemplateInput {
+    
+    approvalRuleTemplateName: string | undefined;
+    
+    approvalRuleTemplateContent: string | undefined;
+    
+    approvalRuleTemplateDescription?: string;
+}
+export declare namespace CreateApprovalRuleTemplateInput {
+    
+    const filterSensitiveLog: (obj: CreateApprovalRuleTemplateInput) => any;
+}
+export interface CreateApprovalRuleTemplateOutput {
+    
+    approvalRuleTemplate: ApprovalRuleTemplate | undefined;
+}
+export declare namespace CreateApprovalRuleTemplateOutput {
+    
+    const filterSensitiveLog: (obj: CreateApprovalRuleTemplateOutput) => any;
+}
+
+export declare class InvalidApprovalRuleTemplateContentException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateContentException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateContentException, __BaseException>);
+}
+
+export declare class InvalidApprovalRuleTemplateDescriptionException extends __BaseException {
+    readonly name: "InvalidApprovalRuleTemplateDescriptionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleTemplateDescriptionException, __BaseException>);
+}
+
+export declare class NumberOfRuleTemplatesExceededException extends __BaseException {
+    readonly name: "NumberOfRuleTemplatesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NumberOfRuleTemplatesExceededException, __BaseException>);
+}
+
+export declare class CommitIdRequiredException extends __BaseException {
+    readonly name: "CommitIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitIdRequiredException, __BaseException>);
+}
+
+export interface CreateBranchInput {
+    
+    repositoryName: string | undefined;
+    
+    branchName: string | undefined;
+    
+    commitId: string | undefined;
+}
+export declare namespace CreateBranchInput {
+    
+    const filterSensitiveLog: (obj: CreateBranchInput) => any;
+}
+
+export declare class InvalidBranchNameException extends __BaseException {
+    readonly name: "InvalidBranchNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidBranchNameException, __BaseException>);
+}
+
+export declare class InvalidCommitIdException extends __BaseException {
+    readonly name: "InvalidCommitIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidCommitIdException, __BaseException>);
+}
+
+export declare class CommitMessageLengthExceededException extends __BaseException {
+    readonly name: "CommitMessageLengthExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitMessageLengthExceededException, __BaseException>);
+}
+
+export interface DeleteFileEntry {
+    
+    filePath: string | undefined;
+}
+export declare namespace DeleteFileEntry {
+    
+    const filterSensitiveLog: (obj: DeleteFileEntry) => any;
+}
+
+export interface SourceFileSpecifier {
+    
+    filePath: string | undefined;
+    
+    isMove?: boolean;
+}
+export declare namespace SourceFileSpecifier {
+    
+    const filterSensitiveLog: (obj: SourceFileSpecifier) => any;
+}
+
+export interface PutFileEntry {
+    
+    filePath: string | undefined;
+    
+    fileMode?: FileModeTypeEnum | string;
+    
+    fileContent?: Uint8Array;
+    
+    sourceFile?: SourceFileSpecifier;
+}
+export declare namespace PutFileEntry {
+    
+    const filterSensitiveLog: (obj: PutFileEntry) => any;
+}
+
+export interface SetFileModeEntry {
+    
+    filePath: string | undefined;
+    
+    fileMode: FileModeTypeEnum | string | undefined;
+}
+export declare namespace SetFileModeEntry {
+    
+    const filterSensitiveLog: (obj: SetFileModeEntry) => any;
+}
+export interface CreateCommitInput {
+    
+    repositoryName: string | undefined;
+    
+    branchName: string | undefined;
+    
+    parentCommitId?: string;
+    
+    authorName?: string;
+    
+    email?: string;
+    
+    commitMessage?: string;
+    
+    keepEmptyFolders?: boolean;
+    
+    putFiles?: PutFileEntry[];
+    
+    deleteFiles?: DeleteFileEntry[];
+    
+    setFileModes?: SetFileModeEntry[];
+}
+export declare namespace CreateCommitInput {
+    
+    const filterSensitiveLog: (obj: CreateCommitInput) => any;
+}
+
+export interface FileMetadata {
+    
+    absolutePath?: string;
+    
+    blobId?: string;
+    
+    fileMode?: FileModeTypeEnum | string;
+}
+export declare namespace FileMetadata {
+    
+    const filterSensitiveLog: (obj: FileMetadata) => any;
+}
+export interface CreateCommitOutput {
+    
+    commitId?: string;
+    
+    treeId?: string;
+    
+    filesAdded?: FileMetadata[];
+    
+    filesUpdated?: FileMetadata[];
+    
+    filesDeleted?: FileMetadata[];
+}
+export declare namespace CreateCommitOutput {
+    
+    const filterSensitiveLog: (obj: CreateCommitOutput) => any;
+}
+
+export declare class DirectoryNameConflictsWithFileNameException extends __BaseException {
+    readonly name: "DirectoryNameConflictsWithFileNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DirectoryNameConflictsWithFileNameException, __BaseException>);
+}
+
+export declare class FileContentAndSourceFileSpecifiedException extends __BaseException {
+    readonly name: "FileContentAndSourceFileSpecifiedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileContentAndSourceFileSpecifiedException, __BaseException>);
+}
+
+export declare class FileContentSizeLimitExceededException extends __BaseException {
+    readonly name: "FileContentSizeLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileContentSizeLimitExceededException, __BaseException>);
+}
+
+export declare class FileDoesNotExistException extends __BaseException {
+    readonly name: "FileDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileDoesNotExistException, __BaseException>);
+}
+
+export declare class FileEntryRequiredException extends __BaseException {
+    readonly name: "FileEntryRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileEntryRequiredException, __BaseException>);
+}
+
+export declare class FileModeRequiredException extends __BaseException {
+    readonly name: "FileModeRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileModeRequiredException, __BaseException>);
+}
+
+export declare class FileNameConflictsWithDirectoryNameException extends __BaseException {
+    readonly name: "FileNameConflictsWithDirectoryNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileNameConflictsWithDirectoryNameException, __BaseException>);
+}
+
+export declare class FilePathConflictsWithSubmodulePathException extends __BaseException {
+    readonly name: "FilePathConflictsWithSubmodulePathException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FilePathConflictsWithSubmodulePathException, __BaseException>);
+}
+
+export declare class FolderContentSizeLimitExceededException extends __BaseException {
+    readonly name: "FolderContentSizeLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FolderContentSizeLimitExceededException, __BaseException>);
+}
+
+export declare class InvalidDeletionParameterException extends __BaseException {
+    readonly name: "InvalidDeletionParameterException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDeletionParameterException, __BaseException>);
+}
+
+export declare class InvalidEmailException extends __BaseException {
+    readonly name: "InvalidEmailException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidEmailException, __BaseException>);
+}
+
+export declare class InvalidFileModeException extends __BaseException {
+    readonly name: "InvalidFileModeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidFileModeException, __BaseException>);
+}
+
+export declare class InvalidParentCommitIdException extends __BaseException {
+    readonly name: "InvalidParentCommitIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParentCommitIdException, __BaseException>);
+}
+
+export declare class InvalidPathException extends __BaseException {
+    readonly name: "InvalidPathException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPathException, __BaseException>);
+}
+
+export declare class MaximumFileEntriesExceededException extends __BaseException {
+    readonly name: "MaximumFileEntriesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumFileEntriesExceededException, __BaseException>);
+}
+
+export declare class NameLengthExceededException extends __BaseException {
+    readonly name: "NameLengthExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NameLengthExceededException, __BaseException>);
+}
+
+export declare class NoChangeException extends __BaseException {
+    readonly name: "NoChangeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NoChangeException, __BaseException>);
+}
+
+export declare class ParentCommitDoesNotExistException extends __BaseException {
+    readonly name: "ParentCommitDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ParentCommitDoesNotExistException, __BaseException>);
+}
+
+export declare class ParentCommitIdOutdatedException extends __BaseException {
+    readonly name: "ParentCommitIdOutdatedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ParentCommitIdOutdatedException, __BaseException>);
+}
+
+export declare class ParentCommitIdRequiredException extends __BaseException {
+    readonly name: "ParentCommitIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ParentCommitIdRequiredException, __BaseException>);
+}
+
+export declare class PathRequiredException extends __BaseException {
+    readonly name: "PathRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PathRequiredException, __BaseException>);
+}
+
+export declare class PutFileEntryConflictException extends __BaseException {
+    readonly name: "PutFileEntryConflictException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PutFileEntryConflictException, __BaseException>);
+}
+
+export declare class RestrictedSourceFileException extends __BaseException {
+    readonly name: "RestrictedSourceFileException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RestrictedSourceFileException, __BaseException>);
+}
+
+export declare class SamePathRequestException extends __BaseException {
+    readonly name: "SamePathRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SamePathRequestException, __BaseException>);
+}
+
+export declare class SourceFileOrContentRequiredException extends __BaseException {
+    readonly name: "SourceFileOrContentRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceFileOrContentRequiredException, __BaseException>);
+}
+
+export interface Target {
+    
+    repositoryName: string | undefined;
+    
+    sourceReference: string | undefined;
+    
+    destinationReference?: string;
+}
+export declare namespace Target {
+    
+    const filterSensitiveLog: (obj: Target) => any;
+}
+export interface CreatePullRequestInput {
+    
+    title: string | undefined;
+    
+    description?: string;
+    
+    targets: Target[] | undefined;
+    
+    clientRequestToken?: string;
+}
+export declare namespace CreatePullRequestInput {
+    
+    const filterSensitiveLog: (obj: CreatePullRequestInput) => any;
+}
+export declare enum PullRequestStatusEnum {
+    CLOSED = "CLOSED",
+    OPEN = "OPEN"
+}
+
+export interface MergeMetadata {
+    
+    isMerged?: boolean;
+    
+    mergedBy?: string;
+    
+    mergeCommitId?: string;
+    
+    mergeOption?: MergeOptionTypeEnum | string;
+}
+export declare namespace MergeMetadata {
+    
+    const filterSensitiveLog: (obj: MergeMetadata) => any;
+}
+
+export interface PullRequestTarget {
+    
+    repositoryName?: string;
+    
+    sourceReference?: string;
+    
+    destinationReference?: string;
+    
+    destinationCommit?: string;
+    
+    sourceCommit?: string;
+    
+    mergeBase?: string;
+    
+    mergeMetadata?: MergeMetadata;
+}
+export declare namespace PullRequestTarget {
+    
+    const filterSensitiveLog: (obj: PullRequestTarget) => any;
+}
+
+export interface PullRequest {
+    
+    pullRequestId?: string;
+    
+    title?: string;
+    
+    description?: string;
+    
+    lastActivityDate?: Date;
+    
+    creationDate?: Date;
+    
+    pullRequestStatus?: PullRequestStatusEnum | string;
+    
+    authorArn?: string;
+    
+    pullRequestTargets?: PullRequestTarget[];
+    
+    clientRequestToken?: string;
+    
+    revisionId?: string;
+    
+    approvalRules?: ApprovalRule[];
+}
+export declare namespace PullRequest {
+    
+    const filterSensitiveLog: (obj: PullRequest) => any;
+}
+export interface CreatePullRequestOutput {
+    
+    pullRequest: PullRequest | undefined;
+}
+export declare namespace CreatePullRequestOutput {
+    
+    const filterSensitiveLog: (obj: CreatePullRequestOutput) => any;
+}
+
+export declare class IdempotencyParameterMismatchException extends __BaseException {
+    readonly name: "IdempotencyParameterMismatchException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<IdempotencyParameterMismatchException, __BaseException>);
+}
+
+export declare class InvalidClientRequestTokenException extends __BaseException {
+    readonly name: "InvalidClientRequestTokenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidClientRequestTokenException, __BaseException>);
+}
+
+export declare class InvalidDescriptionException extends __BaseException {
+    readonly name: "InvalidDescriptionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDescriptionException, __BaseException>);
+}
+
+export declare class InvalidReferenceNameException extends __BaseException {
+    readonly name: "InvalidReferenceNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidReferenceNameException, __BaseException>);
+}
+
+export declare class InvalidTargetException extends __BaseException {
+    readonly name: "InvalidTargetException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTargetException, __BaseException>);
+}
+
+export declare class InvalidTargetsException extends __BaseException {
+    readonly name: "InvalidTargetsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTargetsException, __BaseException>);
+}
+
+export declare class InvalidTitleException extends __BaseException {
+    readonly name: "InvalidTitleException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTitleException, __BaseException>);
+}
+
+export declare class MaximumOpenPullRequestsExceededException extends __BaseException {
+    readonly name: "MaximumOpenPullRequestsExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumOpenPullRequestsExceededException, __BaseException>);
+}
+
+export declare class MultipleRepositoriesInPullRequestException extends __BaseException {
+    readonly name: "MultipleRepositoriesInPullRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MultipleRepositoriesInPullRequestException, __BaseException>);
+}
+
+export declare class ReferenceDoesNotExistException extends __BaseException {
+    readonly name: "ReferenceDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReferenceDoesNotExistException, __BaseException>);
+}
+
+export declare class ReferenceNameRequiredException extends __BaseException {
+    readonly name: "ReferenceNameRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReferenceNameRequiredException, __BaseException>);
+}
+
+export declare class ReferenceTypeNotSupportedException extends __BaseException {
+    readonly name: "ReferenceTypeNotSupportedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReferenceTypeNotSupportedException, __BaseException>);
+}
+
+export declare class SourceAndDestinationAreSameException extends __BaseException {
+    readonly name: "SourceAndDestinationAreSameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceAndDestinationAreSameException, __BaseException>);
+}
+
+export declare class TargetRequiredException extends __BaseException {
+    readonly name: "TargetRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TargetRequiredException, __BaseException>);
+}
+
+export declare class TargetsRequiredException extends __BaseException {
+    readonly name: "TargetsRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TargetsRequiredException, __BaseException>);
+}
+
+export declare class TitleRequiredException extends __BaseException {
+    readonly name: "TitleRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TitleRequiredException, __BaseException>);
+}
+export interface CreatePullRequestApprovalRuleInput {
+    
+    pullRequestId: string | undefined;
+    
+    approvalRuleName: string | undefined;
+    
+    approvalRuleContent: string | undefined;
+}
+export declare namespace CreatePullRequestApprovalRuleInput {
+    
+    const filterSensitiveLog: (obj: CreatePullRequestApprovalRuleInput) => any;
+}
+export interface CreatePullRequestApprovalRuleOutput {
+    
+    approvalRule: ApprovalRule | undefined;
+}
+export declare namespace CreatePullRequestApprovalRuleOutput {
+    
+    const filterSensitiveLog: (obj: CreatePullRequestApprovalRuleOutput) => any;
+}
+
+export declare class InvalidApprovalRuleContentException extends __BaseException {
+    readonly name: "InvalidApprovalRuleContentException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleContentException, __BaseException>);
+}
+
+export declare class InvalidApprovalRuleNameException extends __BaseException {
+    readonly name: "InvalidApprovalRuleNameException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidApprovalRuleNameException, __BaseException>);
+}
+
+export declare class InvalidPullRequestIdException extends __BaseException {
+    readonly name: "InvalidPullRequestIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestIdException, __BaseException>);
+}
+
+export declare class NumberOfRulesExceededException extends __BaseException {
+    readonly name: "NumberOfRulesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NumberOfRulesExceededException, __BaseException>);
+}
+
+export declare class PullRequestAlreadyClosedException extends __BaseException {
+    readonly name: "PullRequestAlreadyClosedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PullRequestAlreadyClosedException, __BaseException>);
+}
+
+export declare class PullRequestDoesNotExistException extends __BaseException {
+    readonly name: "PullRequestDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PullRequestDoesNotExistException, __BaseException>);
+}
+
+export declare class PullRequestIdRequiredException extends __BaseException {
+    readonly name: "PullRequestIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PullRequestIdRequiredException, __BaseException>);
+}
+
+export interface CreateRepositoryInput {
+    
+    repositoryName: string | undefined;
+    
+    repositoryDescription?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateRepositoryInput {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryInput) => any;
+}
+
+export interface CreateRepositoryOutput {
+    
+    repositoryMetadata?: RepositoryMetadata;
+}
+export declare namespace CreateRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: CreateRepositoryOutput) => any;
+}
+
+export declare class InvalidRepositoryDescriptionException extends __BaseException {
+    readonly name: "InvalidRepositoryDescriptionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRepositoryDescriptionException, __BaseException>);
+}
+
+export declare class InvalidSystemTagUsageException extends __BaseException {
+    readonly name: "InvalidSystemTagUsageException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSystemTagUsageException, __BaseException>);
+}
+
+export declare class InvalidTagsMapException extends __BaseException {
+    readonly name: "InvalidTagsMapException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidTagsMapException, __BaseException>);
+}
+
+export declare class RepositoryLimitExceededException extends __BaseException {
+    readonly name: "RepositoryLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryLimitExceededException, __BaseException>);
+}
+
+export declare class RepositoryNameExistsException extends __BaseException {
+    readonly name: "RepositoryNameExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryNameExistsException, __BaseException>);
+}
+
+export declare class TagPolicyException extends __BaseException {
+    readonly name: "TagPolicyException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TagPolicyException, __BaseException>);
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+
+export declare class ConcurrentReferenceUpdateException extends __BaseException {
+    readonly name: "ConcurrentReferenceUpdateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentReferenceUpdateException, __BaseException>);
+}
+export declare enum ReplacementTypeEnum {
+    KEEP_BASE = "KEEP_BASE",
+    KEEP_DESTINATION = "KEEP_DESTINATION",
+    KEEP_SOURCE = "KEEP_SOURCE",
+    USE_NEW_CONTENT = "USE_NEW_CONTENT"
+}
+
+export interface ReplaceContentEntry {
+    
+    filePath: string | undefined;
+    
+    replacementType: ReplacementTypeEnum | string | undefined;
+    
+    content?: Uint8Array;
+    
+    fileMode?: FileModeTypeEnum | string;
+}
+export declare namespace ReplaceContentEntry {
+    
+    const filterSensitiveLog: (obj: ReplaceContentEntry) => any;
+}
+
+export interface ConflictResolution {
+    
+    replaceContents?: ReplaceContentEntry[];
+    
+    deleteFiles?: DeleteFileEntry[];
+    
+    setFileModes?: SetFileModeEntry[];
+}
+export declare namespace ConflictResolution {
+    
+    const filterSensitiveLog: (obj: ConflictResolution) => any;
+}
+export interface CreateUnreferencedMergeCommitInput {
+    
+    repositoryName: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    mergeOption: MergeOptionTypeEnum | string | undefined;
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+    
+    authorName?: string;
+    
+    email?: string;
+    
+    commitMessage?: string;
+    
+    keepEmptyFolders?: boolean;
+    
+    conflictResolution?: ConflictResolution;
+}
+export declare namespace CreateUnreferencedMergeCommitInput {
+    
+    const filterSensitiveLog: (obj: CreateUnreferencedMergeCommitInput) => any;
+}
+export interface CreateUnreferencedMergeCommitOutput {
+    
+    commitId?: string;
+    
+    treeId?: string;
+}
+export declare namespace CreateUnreferencedMergeCommitOutput {
+    
+    const filterSensitiveLog: (obj: CreateUnreferencedMergeCommitOutput) => any;
+}
+
+export declare class InvalidConflictResolutionException extends __BaseException {
+    readonly name: "InvalidConflictResolutionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidConflictResolutionException, __BaseException>);
+}
+
+export declare class InvalidReplacementContentException extends __BaseException {
+    readonly name: "InvalidReplacementContentException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidReplacementContentException, __BaseException>);
+}
+
+export declare class InvalidReplacementTypeException extends __BaseException {
+    readonly name: "InvalidReplacementTypeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidReplacementTypeException, __BaseException>);
+}
+
+export declare class ManualMergeRequiredException extends __BaseException {
+    readonly name: "ManualMergeRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ManualMergeRequiredException, __BaseException>);
+}
+
+export declare class MaximumConflictResolutionEntriesExceededException extends __BaseException {
+    readonly name: "MaximumConflictResolutionEntriesExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MaximumConflictResolutionEntriesExceededException, __BaseException>);
+}
+
+export declare class MultipleConflictResolutionEntriesException extends __BaseException {
+    readonly name: "MultipleConflictResolutionEntriesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<MultipleConflictResolutionEntriesException, __BaseException>);
+}
+
+export declare class ReplacementContentRequiredException extends __BaseException {
+    readonly name: "ReplacementContentRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReplacementContentRequiredException, __BaseException>);
+}
+
+export declare class ReplacementTypeRequiredException extends __BaseException {
+    readonly name: "ReplacementTypeRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ReplacementTypeRequiredException, __BaseException>);
+}
+export interface DeleteApprovalRuleTemplateInput {
+    
+    approvalRuleTemplateName: string | undefined;
+}
+export declare namespace DeleteApprovalRuleTemplateInput {
+    
+    const filterSensitiveLog: (obj: DeleteApprovalRuleTemplateInput) => any;
+}
+export interface DeleteApprovalRuleTemplateOutput {
+    
+    approvalRuleTemplateId: string | undefined;
+}
+export declare namespace DeleteApprovalRuleTemplateOutput {
+    
+    const filterSensitiveLog: (obj: DeleteApprovalRuleTemplateOutput) => any;
+}
+
+export declare class DefaultBranchCannotBeDeletedException extends __BaseException {
+    readonly name: "DefaultBranchCannotBeDeletedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<DefaultBranchCannotBeDeletedException, __BaseException>);
+}
+
+export interface DeleteBranchInput {
+    
+    repositoryName: string | undefined;
+    
+    branchName: string | undefined;
+}
+export declare namespace DeleteBranchInput {
+    
+    const filterSensitiveLog: (obj: DeleteBranchInput) => any;
+}
+
+export interface DeleteBranchOutput {
+    
+    deletedBranch?: BranchInfo;
+}
+export declare namespace DeleteBranchOutput {
+    
+    const filterSensitiveLog: (obj: DeleteBranchOutput) => any;
+}
+
+export declare class CommentDeletedException extends __BaseException {
+    readonly name: "CommentDeletedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommentDeletedException, __BaseException>);
+}
+
+export declare class CommentDoesNotExistException extends __BaseException {
+    readonly name: "CommentDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommentDoesNotExistException, __BaseException>);
+}
+
+export declare class CommentIdRequiredException extends __BaseException {
+    readonly name: "CommentIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommentIdRequiredException, __BaseException>);
+}
+export interface DeleteCommentContentInput {
+    
+    commentId: string | undefined;
+}
+export declare namespace DeleteCommentContentInput {
+    
+    const filterSensitiveLog: (obj: DeleteCommentContentInput) => any;
+}
+
+export interface Comment {
+    
+    commentId?: string;
+    
+    content?: string;
+    
+    inReplyTo?: string;
+    
+    creationDate?: Date;
+    
+    lastModifiedDate?: Date;
+    
+    authorArn?: string;
+    
+    deleted?: boolean;
+    
+    clientRequestToken?: string;
+    
+    callerReactions?: string[];
+    
+    reactionCounts?: {
+        [key: string]: number;
+    };
+}
+export declare namespace Comment {
+    
+    const filterSensitiveLog: (obj: Comment) => any;
+}
+export interface DeleteCommentContentOutput {
+    
+    comment?: Comment;
+}
+export declare namespace DeleteCommentContentOutput {
+    
+    const filterSensitiveLog: (obj: DeleteCommentContentOutput) => any;
+}
+
+export declare class InvalidCommentIdException extends __BaseException {
+    readonly name: "InvalidCommentIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidCommentIdException, __BaseException>);
+}
+export interface DeleteFileInput {
+    
+    repositoryName: string | undefined;
+    
+    branchName: string | undefined;
+    
+    filePath: string | undefined;
+    
+    parentCommitId: string | undefined;
+    
+    keepEmptyFolders?: boolean;
+    
+    commitMessage?: string;
+    
+    name?: string;
+    
+    email?: string;
+}
+export declare namespace DeleteFileInput {
+    
+    const filterSensitiveLog: (obj: DeleteFileInput) => any;
+}
+export interface DeleteFileOutput {
+    
+    commitId: string | undefined;
+    
+    blobId: string | undefined;
+    
+    treeId: string | undefined;
+    
+    filePath: string | undefined;
+}
+export declare namespace DeleteFileOutput {
+    
+    const filterSensitiveLog: (obj: DeleteFileOutput) => any;
+}
+export interface DeletePullRequestApprovalRuleInput {
+    
+    pullRequestId: string | undefined;
+    
+    approvalRuleName: string | undefined;
+}
+export declare namespace DeletePullRequestApprovalRuleInput {
+    
+    const filterSensitiveLog: (obj: DeletePullRequestApprovalRuleInput) => any;
+}
+export interface DeletePullRequestApprovalRuleOutput {
+    
+    approvalRuleId: string | undefined;
+}
+export declare namespace DeletePullRequestApprovalRuleOutput {
+    
+    const filterSensitiveLog: (obj: DeletePullRequestApprovalRuleOutput) => any;
+}
+
+export interface DeleteRepositoryInput {
+    
+    repositoryName: string | undefined;
+}
+export declare namespace DeleteRepositoryInput {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryInput) => any;
+}
+
+export interface DeleteRepositoryOutput {
+    
+    repositoryId?: string;
+}
+export declare namespace DeleteRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: DeleteRepositoryOutput) => any;
+}
+export interface DescribeMergeConflictsInput {
+    
+    repositoryName: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    mergeOption: MergeOptionTypeEnum | string | undefined;
+    
+    maxMergeHunks?: number;
+    
+    filePath: string | undefined;
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeMergeConflictsInput {
+    
+    const filterSensitiveLog: (obj: DescribeMergeConflictsInput) => any;
+}
+export interface DescribeMergeConflictsOutput {
+    
+    conflictMetadata: ConflictMetadata | undefined;
+    
+    mergeHunks: MergeHunk[] | undefined;
+    
+    nextToken?: string;
+    
+    destinationCommitId: string | undefined;
+    
+    sourceCommitId: string | undefined;
+    
+    baseCommitId?: string;
+}
+export declare namespace DescribeMergeConflictsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeMergeConflictsOutput) => any;
+}
+export declare enum PullRequestEventType {
+    PULL_REQUEST_APPROVAL_RULE_CREATED = "PULL_REQUEST_APPROVAL_RULE_CREATED",
+    PULL_REQUEST_APPROVAL_RULE_DELETED = "PULL_REQUEST_APPROVAL_RULE_DELETED",
+    PULL_REQUEST_APPROVAL_RULE_OVERRIDDEN = "PULL_REQUEST_APPROVAL_RULE_OVERRIDDEN",
+    PULL_REQUEST_APPROVAL_RULE_UPDATED = "PULL_REQUEST_APPROVAL_RULE_UPDATED",
+    PULL_REQUEST_APPROVAL_STATE_CHANGED = "PULL_REQUEST_APPROVAL_STATE_CHANGED",
+    PULL_REQUEST_CREATED = "PULL_REQUEST_CREATED",
+    PULL_REQUEST_MERGE_STATE_CHANGED = "PULL_REQUEST_MERGE_STATE_CHANGED",
+    PULL_REQUEST_SOURCE_REFERENCE_UPDATED = "PULL_REQUEST_SOURCE_REFERENCE_UPDATED",
+    PULL_REQUEST_STATUS_CHANGED = "PULL_REQUEST_STATUS_CHANGED"
+}
+export interface DescribePullRequestEventsInput {
+    
+    pullRequestId: string | undefined;
+    
+    pullRequestEventType?: PullRequestEventType | string;
+    
+    actorArn?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace DescribePullRequestEventsInput {
+    
+    const filterSensitiveLog: (obj: DescribePullRequestEventsInput) => any;
+}
+
+export interface PullRequestCreatedEventMetadata {
+    
+    repositoryName?: string;
+    
+    sourceCommitId?: string;
+    
+    destinationCommitId?: string;
+    
+    mergeBase?: string;
+}
+export declare namespace PullRequestCreatedEventMetadata {
+    
+    const filterSensitiveLog: (obj: PullRequestCreatedEventMetadata) => any;
+}
+
+export interface PullRequestMergedStateChangedEventMetadata {
+    
+    repositoryName?: string;
+    
+    destinationReference?: string;
+    
+    mergeMetadata?: MergeMetadata;
+}
+export declare namespace PullRequestMergedStateChangedEventMetadata {
+    
+    const filterSensitiveLog: (obj: PullRequestMergedStateChangedEventMetadata) => any;
+}
+
+export interface PullRequestSourceReferenceUpdatedEventMetadata {
+    
+    repositoryName?: string;
+    
+    beforeCommitId?: string;
+    
+    afterCommitId?: string;
+    
+    mergeBase?: string;
+}
+export declare namespace PullRequestSourceReferenceUpdatedEventMetadata {
+    
+    const filterSensitiveLog: (obj: PullRequestSourceReferenceUpdatedEventMetadata) => any;
+}
+
+export interface PullRequestStatusChangedEventMetadata {
+    
+    pullRequestStatus?: PullRequestStatusEnum | string;
+}
+export declare namespace PullRequestStatusChangedEventMetadata {
+    
+    const filterSensitiveLog: (obj: PullRequestStatusChangedEventMetadata) => any;
+}
+
+export interface PullRequestEvent {
+    
+    pullRequestId?: string;
+    
+    eventDate?: Date;
+    
+    pullRequestEventType?: PullRequestEventType | string;
+    
+    actorArn?: string;
+    
+    pullRequestCreatedEventMetadata?: PullRequestCreatedEventMetadata;
+    
+    pullRequestStatusChangedEventMetadata?: PullRequestStatusChangedEventMetadata;
+    
+    pullRequestSourceReferenceUpdatedEventMetadata?: PullRequestSourceReferenceUpdatedEventMetadata;
+    
+    pullRequestMergedStateChangedEventMetadata?: PullRequestMergedStateChangedEventMetadata;
+    
+    approvalRuleEventMetadata?: ApprovalRuleEventMetadata;
+    
+    approvalStateChangedEventMetadata?: ApprovalStateChangedEventMetadata;
+    
+    approvalRuleOverriddenEventMetadata?: ApprovalRuleOverriddenEventMetadata;
+}
+export declare namespace PullRequestEvent {
+    
+    const filterSensitiveLog: (obj: PullRequestEvent) => any;
+}
+export interface DescribePullRequestEventsOutput {
+    
+    pullRequestEvents: PullRequestEvent[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace DescribePullRequestEventsOutput {
+    
+    const filterSensitiveLog: (obj: DescribePullRequestEventsOutput) => any;
+}
+
+export declare class InvalidActorArnException extends __BaseException {
+    readonly name: "InvalidActorArnException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidActorArnException, __BaseException>);
+}
+
+export declare class InvalidMaxResultsException extends __BaseException {
+    readonly name: "InvalidMaxResultsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidMaxResultsException, __BaseException>);
+}
+
+export declare class InvalidPullRequestEventTypeException extends __BaseException {
+    readonly name: "InvalidPullRequestEventTypeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestEventTypeException, __BaseException>);
+}
+export interface DisassociateApprovalRuleTemplateFromRepositoryInput {
+    
+    approvalRuleTemplateName: string | undefined;
+    
+    repositoryName: string | undefined;
+}
+export declare namespace DisassociateApprovalRuleTemplateFromRepositoryInput {
+    
+    const filterSensitiveLog: (obj: DisassociateApprovalRuleTemplateFromRepositoryInput) => any;
+}
+export interface EvaluatePullRequestApprovalRulesInput {
+    
+    pullRequestId: string | undefined;
+    
+    revisionId: string | undefined;
+}
+export declare namespace EvaluatePullRequestApprovalRulesInput {
+    
+    const filterSensitiveLog: (obj: EvaluatePullRequestApprovalRulesInput) => any;
+}
+
+export interface Evaluation {
+    
+    approved?: boolean;
+    
+    overridden?: boolean;
+    
+    approvalRulesSatisfied?: string[];
+    
+    approvalRulesNotSatisfied?: string[];
+}
+export declare namespace Evaluation {
+    
+    const filterSensitiveLog: (obj: Evaluation) => any;
+}
+export interface EvaluatePullRequestApprovalRulesOutput {
+    
+    evaluation: Evaluation | undefined;
+}
+export declare namespace EvaluatePullRequestApprovalRulesOutput {
+    
+    const filterSensitiveLog: (obj: EvaluatePullRequestApprovalRulesOutput) => any;
+}
+
+export declare class InvalidRevisionIdException extends __BaseException {
+    readonly name: "InvalidRevisionIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRevisionIdException, __BaseException>);
+}
+
+export declare class RevisionIdRequiredException extends __BaseException {
+    readonly name: "RevisionIdRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RevisionIdRequiredException, __BaseException>);
+}
+
+export declare class RevisionNotCurrentException extends __BaseException {
+    readonly name: "RevisionNotCurrentException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RevisionNotCurrentException, __BaseException>);
+}
+export interface GetApprovalRuleTemplateInput {
+    
+    approvalRuleTemplateName: string | undefined;
+}
+export declare namespace GetApprovalRuleTemplateInput {
+    
+    const filterSensitiveLog: (obj: GetApprovalRuleTemplateInput) => any;
+}
+export interface GetApprovalRuleTemplateOutput {
+    
+    approvalRuleTemplate: ApprovalRuleTemplate | undefined;
+}
+export declare namespace GetApprovalRuleTemplateOutput {
+    
+    const filterSensitiveLog: (obj: GetApprovalRuleTemplateOutput) => any;
+}
+
+export declare class FileTooLargeException extends __BaseException {
+    readonly name: "FileTooLargeException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FileTooLargeException, __BaseException>);
+}
+
+export interface GetBlobInput {
+    
+    repositoryName: string | undefined;
+    
+    blobId: string | undefined;
+}
+export declare namespace GetBlobInput {
+    
+    const filterSensitiveLog: (obj: GetBlobInput) => any;
+}
+
+export interface GetBlobOutput {
+    
+    content: Uint8Array | undefined;
+}
+export declare namespace GetBlobOutput {
+    
+    const filterSensitiveLog: (obj: GetBlobOutput) => any;
+}
+
+export declare class InvalidBlobIdException extends __BaseException {
+    readonly name: "InvalidBlobIdException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidBlobIdException, __BaseException>);
+}
+
+export interface GetBranchInput {
+    
+    repositoryName?: string;
+    
+    branchName?: string;
+}
+export declare namespace GetBranchInput {
+    
+    const filterSensitiveLog: (obj: GetBranchInput) => any;
+}
+
+export interface GetBranchOutput {
+    
+    branch?: BranchInfo;
+}
+export declare namespace GetBranchOutput {
+    
+    const filterSensitiveLog: (obj: GetBranchOutput) => any;
+}
+export interface GetCommentInput {
+    
+    commentId: string | undefined;
+}
+export declare namespace GetCommentInput {
+    
+    const filterSensitiveLog: (obj: GetCommentInput) => any;
+}
+export interface GetCommentOutput {
+    
+    comment?: Comment;
+}
+export declare namespace GetCommentOutput {
+    
+    const filterSensitiveLog: (obj: GetCommentOutput) => any;
+}
+export interface GetCommentReactionsInput {
+    
+    commentId: string | undefined;
+    
+    reactionUserArn?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetCommentReactionsInput {
+    
+    const filterSensitiveLog: (obj: GetCommentReactionsInput) => any;
+}
+
+export interface ReactionValueFormats {
+    
+    emoji?: string;
+    
+    shortCode?: string;
+    
+    unicode?: string;
+}
+export declare namespace ReactionValueFormats {
+    
+    const filterSensitiveLog: (obj: ReactionValueFormats) => any;
+}
+
+export interface ReactionForComment {
+    
+    reaction?: ReactionValueFormats;
+    
+    reactionUsers?: string[];
+    
+    reactionsFromDeletedUsersCount?: number;
+}
+export declare namespace ReactionForComment {
+    
+    const filterSensitiveLog: (obj: ReactionForComment) => any;
+}
+export interface GetCommentReactionsOutput {
+    
+    reactionsForComment: ReactionForComment[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace GetCommentReactionsOutput {
+    
+    const filterSensitiveLog: (obj: GetCommentReactionsOutput) => any;
+}
+
+export declare class InvalidReactionUserArnException extends __BaseException {
+    readonly name: "InvalidReactionUserArnException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidReactionUserArnException, __BaseException>);
+}
+export interface GetCommentsForComparedCommitInput {
+    
+    repositoryName: string | undefined;
+    
+    beforeCommitId?: string;
+    
+    afterCommitId: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetCommentsForComparedCommitInput {
+    
+    const filterSensitiveLog: (obj: GetCommentsForComparedCommitInput) => any;
+}
+export declare enum RelativeFileVersionEnum {
+    AFTER = "AFTER",
+    BEFORE = "BEFORE"
+}
+
+export interface Location {
+    
+    filePath?: string;
+    
+    filePosition?: number;
+    
+    relativeFileVersion?: RelativeFileVersionEnum | string;
+}
+export declare namespace Location {
+    
+    const filterSensitiveLog: (obj: Location) => any;
+}
+
+export interface CommentsForComparedCommit {
+    
+    repositoryName?: string;
+    
+    beforeCommitId?: string;
+    
+    afterCommitId?: string;
+    
+    beforeBlobId?: string;
+    
+    afterBlobId?: string;
+    
+    location?: Location;
+    
+    comments?: Comment[];
+}
+export declare namespace CommentsForComparedCommit {
+    
+    const filterSensitiveLog: (obj: CommentsForComparedCommit) => any;
+}
+export interface GetCommentsForComparedCommitOutput {
+    
+    commentsForComparedCommitData?: CommentsForComparedCommit[];
+    
+    nextToken?: string;
+}
+export declare namespace GetCommentsForComparedCommitOutput {
+    
+    const filterSensitiveLog: (obj: GetCommentsForComparedCommitOutput) => any;
+}
+export interface GetCommentsForPullRequestInput {
+    
+    pullRequestId: string | undefined;
+    
+    repositoryName?: string;
+    
+    beforeCommitId?: string;
+    
+    afterCommitId?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace GetCommentsForPullRequestInput {
+    
+    const filterSensitiveLog: (obj: GetCommentsForPullRequestInput) => any;
+}
+
+export interface CommentsForPullRequest {
+    
+    pullRequestId?: string;
+    
+    repositoryName?: string;
+    
+    beforeCommitId?: string;
+    
+    afterCommitId?: string;
+    
+    beforeBlobId?: string;
+    
+    afterBlobId?: string;
+    
+    location?: Location;
+    
+    comments?: Comment[];
+}
+export declare namespace CommentsForPullRequest {
+    
+    const filterSensitiveLog: (obj: CommentsForPullRequest) => any;
+}
+export interface GetCommentsForPullRequestOutput {
+    
+    commentsForPullRequestData?: CommentsForPullRequest[];
+    
+    nextToken?: string;
+}
+export declare namespace GetCommentsForPullRequestOutput {
+    
+    const filterSensitiveLog: (obj: GetCommentsForPullRequestOutput) => any;
+}
+
+export declare class RepositoryNotAssociatedWithPullRequestException extends __BaseException {
+    readonly name: "RepositoryNotAssociatedWithPullRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<RepositoryNotAssociatedWithPullRequestException, __BaseException>);
+}
+
+export declare class CommitIdDoesNotExistException extends __BaseException {
+    readonly name: "CommitIdDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CommitIdDoesNotExistException, __BaseException>);
+}
+
+export interface GetCommitInput {
+    
+    repositoryName: string | undefined;
+    
+    commitId: string | undefined;
+}
+export declare namespace GetCommitInput {
+    
+    const filterSensitiveLog: (obj: GetCommitInput) => any;
+}
+
+export interface GetCommitOutput {
+    
+    commit: Commit | undefined;
+}
+export declare namespace GetCommitOutput {
+    
+    const filterSensitiveLog: (obj: GetCommitOutput) => any;
+}
+export interface GetDifferencesInput {
+    
+    repositoryName: string | undefined;
+    
+    beforeCommitSpecifier?: string;
+    
+    afterCommitSpecifier: string | undefined;
+    
+    beforePath?: string;
+    
+    afterPath?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetDifferencesInput {
+    
+    const filterSensitiveLog: (obj: GetDifferencesInput) => any;
+}
+
+export interface Difference {
+    
+    beforeBlob?: BlobMetadata;
+    
+    afterBlob?: BlobMetadata;
+    
+    changeType?: ChangeTypeEnum | string;
+}
+export declare namespace Difference {
+    
+    const filterSensitiveLog: (obj: Difference) => any;
+}
+export interface GetDifferencesOutput {
+    
+    differences?: Difference[];
+    
+    NextToken?: string;
+}
+export declare namespace GetDifferencesOutput {
+    
+    const filterSensitiveLog: (obj: GetDifferencesOutput) => any;
+}
+
+export declare class PathDoesNotExistException extends __BaseException {
+    readonly name: "PathDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PathDoesNotExistException, __BaseException>);
+}
+export interface GetFileInput {
+    
+    repositoryName: string | undefined;
+    
+    commitSpecifier?: string;
+    
+    filePath: string | undefined;
+}
+export declare namespace GetFileInput {
+    
+    const filterSensitiveLog: (obj: GetFileInput) => any;
+}
+export interface GetFileOutput {
+    
+    commitId: string | undefined;
+    
+    blobId: string | undefined;
+    
+    filePath: string | undefined;
+    
+    fileMode: FileModeTypeEnum | string | undefined;
+    
+    fileSize: number | undefined;
+    
+    fileContent: Uint8Array | undefined;
+}
+export declare namespace GetFileOutput {
+    
+    const filterSensitiveLog: (obj: GetFileOutput) => any;
+}
+
+export declare class FolderDoesNotExistException extends __BaseException {
+    readonly name: "FolderDoesNotExistException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<FolderDoesNotExistException, __BaseException>);
+}
+export interface GetFolderInput {
+    
+    repositoryName: string | undefined;
+    
+    commitSpecifier?: string;
+    
+    folderPath: string | undefined;
+}
+export declare namespace GetFolderInput {
+    
+    const filterSensitiveLog: (obj: GetFolderInput) => any;
+}
+
+export interface File {
+    
+    blobId?: string;
+    
+    absolutePath?: string;
+    
+    relativePath?: string;
+    
+    fileMode?: FileModeTypeEnum | string;
+}
+export declare namespace File {
+    
+    const filterSensitiveLog: (obj: File) => any;
+}
+
+export interface Folder {
+    
+    treeId?: string;
+    
+    absolutePath?: string;
+    
+    relativePath?: string;
+}
+export declare namespace Folder {
+    
+    const filterSensitiveLog: (obj: Folder) => any;
+}
+
+export interface SubModule {
+    
+    commitId?: string;
+    
+    absolutePath?: string;
+    
+    relativePath?: string;
+}
+export declare namespace SubModule {
+    
+    const filterSensitiveLog: (obj: SubModule) => any;
+}
+
+export interface SymbolicLink {
+    
+    blobId?: string;
+    
+    absolutePath?: string;
+    
+    relativePath?: string;
+    
+    fileMode?: FileModeTypeEnum | string;
+}
+export declare namespace SymbolicLink {
+    
+    const filterSensitiveLog: (obj: SymbolicLink) => any;
+}
+export interface GetFolderOutput {
+    
+    commitId: string | undefined;
+    
+    folderPath: string | undefined;
+    
+    treeId?: string;
+    
+    subFolders?: Folder[];
+    
+    files?: File[];
+    
+    symbolicLinks?: SymbolicLink[];
+    
+    subModules?: SubModule[];
+}
+export declare namespace GetFolderOutput {
+    
+    const filterSensitiveLog: (obj: GetFolderOutput) => any;
+}
+export interface GetMergeCommitInput {
+    
+    repositoryName: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+}
+export declare namespace GetMergeCommitInput {
+    
+    const filterSensitiveLog: (obj: GetMergeCommitInput) => any;
+}
+export interface GetMergeCommitOutput {
+    
+    sourceCommitId?: string;
+    
+    destinationCommitId?: string;
+    
+    baseCommitId?: string;
+    
+    mergedCommitId?: string;
+}
+export declare namespace GetMergeCommitOutput {
+    
+    const filterSensitiveLog: (obj: GetMergeCommitOutput) => any;
+}
+export interface GetMergeConflictsInput {
+    
+    repositoryName: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    mergeOption: MergeOptionTypeEnum | string | undefined;
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    maxConflictFiles?: number;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+    
+    nextToken?: string;
+}
+export declare namespace GetMergeConflictsInput {
+    
+    const filterSensitiveLog: (obj: GetMergeConflictsInput) => any;
+}
+export interface GetMergeConflictsOutput {
+    
+    mergeable: boolean | undefined;
+    
+    destinationCommitId: string | undefined;
+    
+    sourceCommitId: string | undefined;
+    
+    baseCommitId?: string;
+    
+    conflictMetadataList: ConflictMetadata[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace GetMergeConflictsOutput {
+    
+    const filterSensitiveLog: (obj: GetMergeConflictsOutput) => any;
+}
+
+export declare class InvalidDestinationCommitSpecifierException extends __BaseException {
+    readonly name: "InvalidDestinationCommitSpecifierException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidDestinationCommitSpecifierException, __BaseException>);
+}
+
+export declare class InvalidSourceCommitSpecifierException extends __BaseException {
+    readonly name: "InvalidSourceCommitSpecifierException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSourceCommitSpecifierException, __BaseException>);
+}
+export interface GetMergeOptionsInput {
+    
+    repositoryName: string | undefined;
+    
+    sourceCommitSpecifier: string | undefined;
+    
+    destinationCommitSpecifier: string | undefined;
+    
+    conflictDetailLevel?: ConflictDetailLevelTypeEnum | string;
+    
+    conflictResolutionStrategy?: ConflictResolutionStrategyTypeEnum | string;
+}
+export declare namespace GetMergeOptionsInput {
+    
+    const filterSensitiveLog: (obj: GetMergeOptionsInput) => any;
+}
+export interface GetMergeOptionsOutput {
+    
+    mergeOptions: (MergeOptionTypeEnum | string)[] | undefined;
+    
+    sourceCommitId: string | undefined;
+    
+    destinationCommitId: string | undefined;
+    
+    baseCommitId: string | undefined;
+}
+export declare namespace GetMergeOptionsOutput {
+    
+    const filterSensitiveLog: (obj: GetMergeOptionsOutput) => any;
+}
+export interface GetPullRequestInput {
+    
+    pullRequestId: string | undefined;
+}
+export declare namespace GetPullRequestInput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestInput) => any;
+}
+export interface GetPullRequestOutput {
+    
+    pullRequest: PullRequest | undefined;
+}
+export declare namespace GetPullRequestOutput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestOutput) => any;
+}
+export interface GetPullRequestApprovalStatesInput {
+    
+    pullRequestId: string | undefined;
+    
+    revisionId: string | undefined;
+}
+export declare namespace GetPullRequestApprovalStatesInput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestApprovalStatesInput) => any;
+}
+export interface GetPullRequestApprovalStatesOutput {
+    
+    approvals?: Approval[];
+}
+export declare namespace GetPullRequestApprovalStatesOutput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestApprovalStatesOutput) => any;
+}
+export interface GetPullRequestOverrideStateInput {
+    
+    pullRequestId: string | undefined;
+    
+    revisionId: string | undefined;
+}
+export declare namespace GetPullRequestOverrideStateInput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestOverrideStateInput) => any;
+}
+export interface GetPullRequestOverrideStateOutput {
+    
+    overridden?: boolean;
+    
+    overrider?: string;
+}
+export declare namespace GetPullRequestOverrideStateOutput {
+    
+    const filterSensitiveLog: (obj: GetPullRequestOverrideStateOutput) => any;
+}
+
+export interface GetRepositoryInput {
+    
+    repositoryName: string | undefined;
+}
+export declare namespace GetRepositoryInput {
+    
+    const filterSensitiveLog: (obj: GetRepositoryInput) => any;
+}
+
+export interface GetRepositoryOutput {
+    
+    repositoryMetadata?: RepositoryMetadata;
+}
+export declare namespace GetRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: GetRepositoryOutput) => any;
+}
+
+export interface GetRepositoryTriggersInput {
+    
+    repositoryName: string | undefined;
+}
+export declare namespace GetRepositoryTriggersInput {
+    
+    const filterSensitiveLog: (obj: GetRepositoryTriggersInput) => any;
+}
+export declare enum RepositoryTriggerEventEnum {
+    ALL = "all",
+    CREATE_REFERENCE = "createReference",
+    DELETE_REFERENCE = "deleteReference",
+    UPDATE_REFERENCE = "updateReference"
+}
+
+export interface RepositoryTrigger {
+    
+    name: string | undefined;
+    
+    destinationArn: string | undefined;
+    
+    customData?: string;
+    
+    branches?: string[];
+    
+    events: (RepositoryTriggerEventEnum | string)[] | undefined;
+}
+export declare namespace RepositoryTrigger {
+    
+    const filterSensitiveLog: (obj: RepositoryTrigger) => any;
+}
+
+export interface GetRepositoryTriggersOutput {
+    
+    configurationId?: string;
+    
+    triggers?: RepositoryTrigger[];
+}
+export declare namespace GetRepositoryTriggersOutput {
+    
+    const filterSensitiveLog: (obj: GetRepositoryTriggersOutput) => any;
+}
+export interface ListApprovalRuleTemplatesInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListApprovalRuleTemplatesInput {
+    
+    const filterSensitiveLog: (obj: ListApprovalRuleTemplatesInput) => any;
+}
+export interface ListApprovalRuleTemplatesOutput {
+    
+    approvalRuleTemplateNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListApprovalRuleTemplatesOutput {
+    
+    const filterSensitiveLog: (obj: ListApprovalRuleTemplatesOutput) => any;
+}
+export interface ListAssociatedApprovalRuleTemplatesForRepositoryInput {
+    
+    repositoryName: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListAssociatedApprovalRuleTemplatesForRepositoryInput {
+    
+    const filterSensitiveLog: (obj: ListAssociatedApprovalRuleTemplatesForRepositoryInput) => any;
+}
+export interface ListAssociatedApprovalRuleTemplatesForRepositoryOutput {
+    
+    approvalRuleTemplateNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListAssociatedApprovalRuleTemplatesForRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: ListAssociatedApprovalRuleTemplatesForRepositoryOutput) => any;
+}
+
+export interface ListBranchesInput {
+    
+    repositoryName: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListBranchesInput {
+    
+    const filterSensitiveLog: (obj: ListBranchesInput) => any;
+}
+
+export interface ListBranchesOutput {
+    
+    branches?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListBranchesOutput {
+    
+    const filterSensitiveLog: (obj: ListBranchesOutput) => any;
+}
+
+export declare class InvalidAuthorArnException extends __BaseException {
+    readonly name: "InvalidAuthorArnException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidAuthorArnException, __BaseException>);
+}
+
+export declare class InvalidPullRequestStatusException extends __BaseException {
+    readonly name: "InvalidPullRequestStatusException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidPullRequestStatusException, __BaseException>);
+}
+export interface ListPullRequestsInput {
+    
+    repositoryName: string | undefined;
+    
+    authorArn?: string;
+    
+    pullRequestStatus?: PullRequestStatusEnum | string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListPullRequestsInput {
+    
+    const filterSensitiveLog: (obj: ListPullRequestsInput) => any;
+}
+export interface ListPullRequestsOutput {
+    
+    pullRequestIds: string[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListPullRequestsOutput {
+    
+    const filterSensitiveLog: (obj: ListPullRequestsOutput) => any;
+}
+
+export declare class InvalidOrderException extends __BaseException {
+    readonly name: "InvalidOrderException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidOrderException, __BaseException>);
+}
+
+export declare class InvalidSortByException extends __BaseException {
+    readonly name: "InvalidSortByException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidSortByException, __BaseException>);
+}