import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";

export interface AccountLimitExceededException extends __SmithyException, $MetadataBearer {
    name: "AccountLimitExceededException";
    $fault: "client";
    message?: string;
}
export declare namespace AccountLimitExceededException {
    
    const filterSensitiveLog: (obj: AccountLimitExceededException) => any;
}
export declare enum ArtifactNamespace {
    BUILD_ID = "BUILD_ID",
    NONE = "NONE"
}
export declare enum ArtifactPackaging {
    NONE = "NONE",
    ZIP = "ZIP"
}
export declare enum ArtifactsType {
    CODEPIPELINE = "CODEPIPELINE",
    NO_ARTIFACTS = "NO_ARTIFACTS",
    S3 = "S3"
}
export declare enum AuthType {
    BASIC_AUTH = "BASIC_AUTH",
    OAUTH = "OAUTH",
    PERSONAL_ACCESS_TOKEN = "PERSONAL_ACCESS_TOKEN"
}
export interface BatchDeleteBuildsInput {
    
    ids: string[] | undefined;
}
export declare namespace BatchDeleteBuildsInput {
    
    const filterSensitiveLog: (obj: BatchDeleteBuildsInput) => any;
}

export interface BuildNotDeleted {
    
    id?: string;
    
    statusCode?: string;
}
export declare namespace BuildNotDeleted {
    
    const filterSensitiveLog: (obj: BuildNotDeleted) => any;
}
export interface BatchDeleteBuildsOutput {
    
    buildsDeleted?: string[];
    
    buildsNotDeleted?: BuildNotDeleted[];
}
export declare namespace BatchDeleteBuildsOutput {
    
    const filterSensitiveLog: (obj: BatchDeleteBuildsOutput) => any;
}

export interface InvalidInputException extends __SmithyException, $MetadataBearer {
    name: "InvalidInputException";
    $fault: "client";
    message?: string;
}
export declare namespace InvalidInputException {
    
    const filterSensitiveLog: (obj: InvalidInputException) => any;
}
export interface BatchGetBuildBatchesInput {
    
    ids: string[] | undefined;
}
export declare namespace BatchGetBuildBatchesInput {
    
    const filterSensitiveLog: (obj: BatchGetBuildBatchesInput) => any;
}
export declare enum BucketOwnerAccess {
    FULL = "FULL",
    NONE = "NONE",
    READ_ONLY = "READ_ONLY"
}

export interface BuildArtifacts {
    
    location?: string;
    
    sha256sum?: string;
    
    md5sum?: string;
    
    overrideArtifactName?: boolean;
    
    encryptionDisabled?: boolean;
    
    artifactIdentifier?: string;
    
    bucketOwnerAccess?: BucketOwnerAccess | string;
}
export declare namespace BuildArtifacts {
    
    const filterSensitiveLog: (obj: BuildArtifacts) => any;
}
export declare enum BatchReportModeType {
    REPORT_AGGREGATED_BATCH = "REPORT_AGGREGATED_BATCH",
    REPORT_INDIVIDUAL_BUILDS = "REPORT_INDIVIDUAL_BUILDS"
}

export interface BatchRestrictions {
    
    maximumBuildsAllowed?: number;
    
    computeTypesAllowed?: string[];
}
export declare namespace BatchRestrictions {
    
    const filterSensitiveLog: (obj: BatchRestrictions) => any;
}

export interface ProjectBuildBatchConfig {
    
    serviceRole?: string;
    
    combineArtifacts?: boolean;
    
    restrictions?: BatchRestrictions;
    
    timeoutInMins?: number;
    
    batchReportMode?: BatchReportModeType | string;
}
export declare namespace ProjectBuildBatchConfig {
    
    const filterSensitiveLog: (obj: ProjectBuildBatchConfig) => any;
}
export declare enum StatusType {
    FAILED = "FAILED",
    FAULT = "FAULT",
    IN_PROGRESS = "IN_PROGRESS",
    STOPPED = "STOPPED",
    SUCCEEDED = "SUCCEEDED",
    TIMED_OUT = "TIMED_OUT"
}

export interface ResolvedArtifact {
    
    type?: ArtifactsType | string;
    
    location?: string;
    
    identifier?: string;
}
export declare namespace ResolvedArtifact {
    
    const filterSensitiveLog: (obj: ResolvedArtifact) => any;
}

export interface BuildSummary {
    
    arn?: string;
    
    requestedOn?: Date;
    
    buildStatus?: StatusType | string;
    
    primaryArtifact?: ResolvedArtifact;
    
    secondaryArtifacts?: ResolvedArtifact[];
}
export declare namespace BuildSummary {
    
    const filterSensitiveLog: (obj: BuildSummary) => any;
}

export interface BuildGroup {
    
    identifier?: string;
    
    dependsOn?: string[];
    
    ignoreFailure?: boolean;
    
    currentBuildSummary?: BuildSummary;
    
    priorBuildSummaryList?: BuildSummary[];
}
export declare namespace BuildGroup {
    
    const filterSensitiveLog: (obj: BuildGroup) => any;
}
export declare enum CacheMode {
    LOCAL_CUSTOM_CACHE = "LOCAL_CUSTOM_CACHE",
    LOCAL_DOCKER_LAYER_CACHE = "LOCAL_DOCKER_LAYER_CACHE",
    LOCAL_SOURCE_CACHE = "LOCAL_SOURCE_CACHE"
}
export declare enum CacheType {
    LOCAL = "LOCAL",
    NO_CACHE = "NO_CACHE",
    S3 = "S3"
}

export interface ProjectCache {
    
    type: CacheType | string | undefined;
    
    location?: string;
    
    modes?: (CacheMode | string)[];
}
export declare namespace ProjectCache {
    
    const filterSensitiveLog: (obj: ProjectCache) => any;
}
export declare enum ComputeType {
    BUILD_GENERAL1_2XLARGE = "BUILD_GENERAL1_2XLARGE",
    BUILD_GENERAL1_LARGE = "BUILD_GENERAL1_LARGE",
    BUILD_GENERAL1_MEDIUM = "BUILD_GENERAL1_MEDIUM",
    BUILD_GENERAL1_SMALL = "BUILD_GENERAL1_SMALL"
}
export declare enum EnvironmentVariableType {
    PARAMETER_STORE = "PARAMETER_STORE",
    PLAINTEXT = "PLAINTEXT",
    SECRETS_MANAGER = "SECRETS_MANAGER"
}

export interface EnvironmentVariable {
    
    name: string | undefined;
    
    value: string | undefined;
    
    type?: EnvironmentVariableType | string;
}
export declare namespace EnvironmentVariable {
    
    const filterSensitiveLog: (obj: EnvironmentVariable) => any;
}
export declare enum ImagePullCredentialsType {
    CODEBUILD = "CODEBUILD",
    SERVICE_ROLE = "SERVICE_ROLE"
}
export declare enum CredentialProviderType {
    SECRETS_MANAGER = "SECRETS_MANAGER"
}

export interface RegistryCredential {
    
    credential: string | undefined;
    
    credentialProvider: CredentialProviderType | string | undefined;
}
export declare namespace RegistryCredential {
    
    const filterSensitiveLog: (obj: RegistryCredential) => any;
}
export declare enum EnvironmentType {
    ARM_CONTAINER = "ARM_CONTAINER",
    LINUX_CONTAINER = "LINUX_CONTAINER",
    LINUX_GPU_CONTAINER = "LINUX_GPU_CONTAINER",
    WINDOWS_CONTAINER = "WINDOWS_CONTAINER",
    WINDOWS_SERVER_2019_CONTAINER = "WINDOWS_SERVER_2019_CONTAINER"
}

export interface ProjectEnvironment {
    
    type: EnvironmentType | string | undefined;
    
    image: string | undefined;
    
    computeType: ComputeType | string | undefined;
    
    environmentVariables?: EnvironmentVariable[];
    
    privilegedMode?: boolean;
    
    certificate?: string;
    
    registryCredential?: RegistryCredential;
    
    imagePullCredentialsType?: ImagePullCredentialsType | string;
}
export declare namespace ProjectEnvironment {
    
    const filterSensitiveLog: (obj: ProjectEnvironment) => any;
}
export declare enum FileSystemType {
    EFS = "EFS"
}

export interface ProjectFileSystemLocation {
    
    type?: FileSystemType | string;
    
    location?: string;
    
    mountPoint?: string;
    
    identifier?: string;
    
    mountOptions?: string;
}
export declare namespace ProjectFileSystemLocation {
    
    const filterSensitiveLog: (obj: ProjectFileSystemLocation) => any;
}
export declare enum LogsConfigStatusType {
    DISABLED = "DISABLED",
    ENABLED = "ENABLED"
}

export interface CloudWatchLogsConfig {
    
    status: LogsConfigStatusType | string | undefined;
    
    groupName?: string;
    
    streamName?: string;
}
export declare namespace CloudWatchLogsConfig {
    
    const filterSensitiveLog: (obj: CloudWatchLogsConfig) => any;
}

export interface S3LogsConfig {
    
    status: LogsConfigStatusType | string | undefined;
    
    location?: string;
    
    encryptionDisabled?: boolean;
    
    bucketOwnerAccess?: BucketOwnerAccess | string;
}
export declare namespace S3LogsConfig {
    
    const filterSensitiveLog: (obj: S3LogsConfig) => any;
}

export interface LogsConfig {
    
    cloudWatchLogs?: CloudWatchLogsConfig;
    
    s3Logs?: S3LogsConfig;
}
export declare namespace LogsConfig {
    
    const filterSensitiveLog: (obj: LogsConfig) => any;
}

export interface PhaseContext {
    
    statusCode?: string;
    
    message?: string;
}
export declare namespace PhaseContext {
    
    const filterSensitiveLog: (obj: PhaseContext) => any;
}
export declare enum BuildBatchPhaseType {
    COMBINE_ARTIFACTS = "COMBINE_ARTIFACTS",
    DOWNLOAD_BATCHSPEC = "DOWNLOAD_BATCHSPEC",
    FAILED = "FAILED",
    IN_PROGRESS = "IN_PROGRESS",
    STOPPED = "STOPPED",
    SUBMITTED = "SUBMITTED",
    SUCCEEDED = "SUCCEEDED"
}

export interface BuildBatchPhase {
    
    phaseType?: BuildBatchPhaseType | string;
    
    phaseStatus?: StatusType | string;
    
    startTime?: Date;
    
    endTime?: Date;
    
    durationInSeconds?: number;
    
    contexts?: PhaseContext[];
}
export declare namespace BuildBatchPhase {
    
    const filterSensitiveLog: (obj: BuildBatchPhase) => any;
}
export declare enum SourceAuthType {
    OAUTH = "OAUTH"
}

export interface SourceAuth {
    
    type: SourceAuthType | string | undefined;
    
    resource?: string;
}
export declare namespace SourceAuth {
    
    const filterSensitiveLog: (obj: SourceAuth) => any;
}

export interface BuildStatusConfig {
    
    context?: string;
    
    targetUrl?: string;
}
export declare namespace BuildStatusConfig {
    
    const filterSensitiveLog: (obj: BuildStatusConfig) => any;
}

export interface GitSubmodulesConfig {
    
    fetchSubmodules: boolean | undefined;
}
export declare namespace GitSubmodulesConfig {
    
    const filterSensitiveLog: (obj: GitSubmodulesConfig) => any;
}
export declare enum SourceType {
    BITBUCKET = "BITBUCKET",
    CODECOMMIT = "CODECOMMIT",
    CODEPIPELINE = "CODEPIPELINE",
    GITHUB = "GITHUB",
    GITHUB_ENTERPRISE = "GITHUB_ENTERPRISE",
    NO_SOURCE = "NO_SOURCE",
    S3 = "S3"
}

export interface ProjectSource {
    
    type: SourceType | string | undefined;
    
    location?: string;
    
    gitCloneDepth?: number;
    
    gitSubmodulesConfig?: GitSubmodulesConfig;
    
    buildspec?: string;
    
    auth?: SourceAuth;
    
    reportBuildStatus?: boolean;
    
    buildStatusConfig?: BuildStatusConfig;
    
    insecureSsl?: boolean;
    
    sourceIdentifier?: string;
}
export declare namespace ProjectSource {
    
    const filterSensitiveLog: (obj: ProjectSource) => any;
}

export interface ProjectSourceVersion {
    
    sourceIdentifier: string | undefined;
    
    sourceVersion: string | undefined;
}
export declare namespace ProjectSourceVersion {
    
    const filterSensitiveLog: (obj: ProjectSourceVersion) => any;
}

export interface VpcConfig {
    
    vpcId?: string;
    
    subnets?: string[];
    
    securityGroupIds?: string[];
}
export declare namespace VpcConfig {
    
    const filterSensitiveLog: (obj: VpcConfig) => any;
}

export interface BuildBatch {
    
    id?: string;
    
    arn?: string;
    
    startTime?: Date;
    
    endTime?: Date;
    
    currentPhase?: string;
    
    buildBatchStatus?: StatusType | string;
    
    sourceVersion?: string;
    
    resolvedSourceVersion?: string;
    
    projectName?: string;
    
    phases?: BuildBatchPhase[];
    
    source?: ProjectSource;
    
    secondarySources?: ProjectSource[];
    
    secondarySourceVersions?: ProjectSourceVersion[];
    
    artifacts?: BuildArtifacts;
    
    secondaryArtifacts?: BuildArtifacts[];
    
    cache?: ProjectCache;
    
    environment?: ProjectEnvironment;
    
    serviceRole?: string;
    
    logConfig?: LogsConfig;
    
    buildTimeoutInMinutes?: number;
    
    queuedTimeoutInMinutes?: number;
    
    complete?: boolean;
    
    initiator?: string;
    
    vpcConfig?: VpcConfig;
    
    encryptionKey?: string;
    
    buildBatchNumber?: number;
    
    fileSystemLocations?: ProjectFileSystemLocation[];
    
    buildBatchConfig?: ProjectBuildBatchConfig;
    
    buildGroups?: BuildGroup[];
    
    debugSessionEnabled?: boolean;
}
export declare namespace BuildBatch {
    
    const filterSensitiveLog: (obj: BuildBatch) => any;
}
export interface BatchGetBuildBatchesOutput {
    
    buildBatches?: BuildBatch[];
    
    buildBatchesNotFound?: string[];
}
export declare namespace BatchGetBuildBatchesOutput {
    
    const filterSensitiveLog: (obj: BatchGetBuildBatchesOutput) => any;
}
export interface BatchGetBuildsInput {
    
    ids: string[] | undefined;
}
export declare namespace BatchGetBuildsInput {
    
    const filterSensitiveLog: (obj: BatchGetBuildsInput) => any;
}

export interface DebugSession {
    
    sessionEnabled?: boolean;
    
    sessionTarget?: string;
}
export declare namespace DebugSession {
    
    const filterSensitiveLog: (obj: DebugSession) => any;
}

export interface ExportedEnvironmentVariable {
    
    name?: string;
    
    value?: string;
}
export declare namespace ExportedEnvironmentVariable {
    
    const filterSensitiveLog: (obj: ExportedEnvironmentVariable) => any;
}

export interface LogsLocation {
    
    groupName?: string;
    
    streamName?: string;
    
    deepLink?: string;
    
    s3DeepLink?: string;
    
    cloudWatchLogsArn?: string;
    
    s3LogsArn?: string;
    
    cloudWatchLogs?: CloudWatchLogsConfig;
    
    s3Logs?: S3LogsConfig;
}
export declare namespace LogsLocation {
    
    const filterSensitiveLog: (obj: LogsLocation) => any;
}

export interface NetworkInterface {
    
    subnetId?: string;
    
    networkInterfaceId?: string;
}
export declare namespace NetworkInterface {
    
    const filterSensitiveLog: (obj: NetworkInterface) => any;
}
export declare enum BuildPhaseType {
    BUILD = "BUILD",
    COMPLETED = "COMPLETED",
    DOWNLOAD_SOURCE = "DOWNLOAD_SOURCE",
    FINALIZING = "FINALIZING",
    INSTALL = "INSTALL",
    POST_BUILD = "POST_BUILD",
    PRE_BUILD = "PRE_BUILD",
    PROVISIONING = "PROVISIONING",
    QUEUED = "QUEUED",
    SUBMITTED = "SUBMITTED",
    UPLOAD_ARTIFACTS = "UPLOAD_ARTIFACTS"
}

export interface BuildPhase {
    
    phaseType?: BuildPhaseType | string;
    
    phaseStatus?: StatusType | string;
    
    startTime?: Date;
    
    endTime?: Date;
    
    durationInSeconds?: number;
    
    contexts?: PhaseContext[];
}
export declare namespace BuildPhase {
    
    const filterSensitiveLog: (obj: BuildPhase) => any;
}

export interface Build {
    
    id?: string;
    
    arn?: string;
    
    buildNumber?: number;
    
    startTime?: Date;
    
    endTime?: Date;
    
    currentPhase?: string;
    
    buildStatus?: StatusType | string;
    
    sourceVersion?: string;
    
    resolvedSourceVersion?: string;
    
    projectName?: string;
    
    phases?: BuildPhase[];
    
    source?: ProjectSource;
    
    secondarySources?: ProjectSource[];
    
    secondarySourceVersions?: ProjectSourceVersion[];
    
    artifacts?: BuildArtifacts;
    
    secondaryArtifacts?: BuildArtifacts[];
    
    cache?: ProjectCache;
    
    environment?: ProjectEnvironment;
    
    serviceRole?: string;
    
    logs?: LogsLocation;
    
    timeoutInMinutes?: number;
    
    queuedTimeoutInMinutes?: number;
    
    buildComplete?: boolean;
    
    initiator?: string;
    
    vpcConfig?: VpcConfig;
    
    networkInterface?: NetworkInterface;
    
    encryptionKey?: string;
    
    exportedEnvironmentVariables?: ExportedEnvironmentVariable[];
    
    reportArns?: string[];
    
    fileSystemLocations?: ProjectFileSystemLocation[];
    
    debugSession?: DebugSession;
    
    buildBatchArn?: string;
}
export declare namespace Build {
    
    const filterSensitiveLog: (obj: Build) => any;
}
export interface BatchGetBuildsOutput {
    
    builds?: Build[];
    
    buildsNotFound?: string[];
}
export declare namespace BatchGetBuildsOutput {
    
    const filterSensitiveLog: (obj: BatchGetBuildsOutput) => any;
}
export interface BatchGetProjectsInput {
    
    names: string[] | undefined;
}
export declare namespace BatchGetProjectsInput {
    
    const filterSensitiveLog: (obj: BatchGetProjectsInput) => any;
}

export interface ProjectArtifacts {
    
    type: ArtifactsType | string | undefined;
    
    location?: string;
    
    path?: string;
    
    namespaceType?: ArtifactNamespace | string;
    
    name?: string;
    
    packaging?: ArtifactPackaging | string;
    
    overrideArtifactName?: boolean;
    
    encryptionDisabled?: boolean;
    
    artifactIdentifier?: string;
    
    bucketOwnerAccess?: BucketOwnerAccess | string;
}
export declare namespace ProjectArtifacts {
    
    const filterSensitiveLog: (obj: ProjectArtifacts) => any;
}

export interface ProjectBadge {
    
    badgeEnabled?: boolean;
    
    badgeRequestUrl?: string;
}
export declare namespace ProjectBadge {
    
    const filterSensitiveLog: (obj: ProjectBadge) => any;
}
export declare enum ProjectVisibilityType {
    PRIVATE = "PRIVATE",
    PUBLIC_READ = "PUBLIC_READ"
}

export interface Tag {
    
    key?: string;
    
    value?: string;
}
export declare namespace Tag {
    
    const filterSensitiveLog: (obj: Tag) => any;
}
export declare enum WebhookBuildType {
    BUILD = "BUILD",
    BUILD_BATCH = "BUILD_BATCH"
}
export declare enum WebhookFilterType {
    ACTOR_ACCOUNT_ID = "ACTOR_ACCOUNT_ID",
    BASE_REF = "BASE_REF",
    COMMIT_MESSAGE = "COMMIT_MESSAGE",
    EVENT = "EVENT",
    FILE_PATH = "FILE_PATH",
    HEAD_REF = "HEAD_REF"
}

export interface WebhookFilter {
    
    type: WebhookFilterType | string | undefined;
    
    pattern: string | undefined;
    
    excludeMatchedPattern?: boolean;
}
export declare namespace WebhookFilter {
    
    const filterSensitiveLog: (obj: WebhookFilter) => any;
}

export interface Webhook {
    
    url?: string;
    
    payloadUrl?: string;
    
    secret?: string;
    
    branchFilter?: string;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
    
    lastModifiedSecret?: Date;
}
export declare namespace Webhook {
    
    const filterSensitiveLog: (obj: Webhook) => any;
}

export interface Project {
    
    name?: string;
    
    arn?: string;
    
    description?: string;
    
    source?: ProjectSource;
    
    secondarySources?: ProjectSource[];
    
    sourceVersion?: string;
    
    secondarySourceVersions?: ProjectSourceVersion[];
    
    artifacts?: ProjectArtifacts;
    
    secondaryArtifacts?: ProjectArtifacts[];
    
    cache?: ProjectCache;
    
    environment?: ProjectEnvironment;
    
    serviceRole?: string;
    
    timeoutInMinutes?: number;
    
    queuedTimeoutInMinutes?: number;
    
    encryptionKey?: string;
    
    tags?: Tag[];
    
    created?: Date;
    
    lastModified?: Date;
    
    webhook?: Webhook;
    
    vpcConfig?: VpcConfig;
    
    badge?: ProjectBadge;
    
    logsConfig?: LogsConfig;
    
    fileSystemLocations?: ProjectFileSystemLocation[];
    
    buildBatchConfig?: ProjectBuildBatchConfig;
    
    concurrentBuildLimit?: number;
    
    projectVisibility?: ProjectVisibilityType | string;
    
    publicProjectAlias?: string;
    
    resourceAccessRole?: string;
}
export declare namespace Project {
    
    const filterSensitiveLog: (obj: Project) => any;
}
export interface BatchGetProjectsOutput {
    
    projects?: Project[];
    
    projectsNotFound?: string[];
}
export declare namespace BatchGetProjectsOutput {
    
    const filterSensitiveLog: (obj: BatchGetProjectsOutput) => any;
}
export interface BatchGetReportGroupsInput {
    
    reportGroupArns: string[] | undefined;
}
export declare namespace BatchGetReportGroupsInput {
    
    const filterSensitiveLog: (obj: BatchGetReportGroupsInput) => any;
}
export declare enum ReportExportConfigType {
    NO_EXPORT = "NO_EXPORT",
    S3 = "S3"
}
export declare enum ReportPackagingType {
    NONE = "NONE",
    ZIP = "ZIP"
}

export interface S3ReportExportConfig {
    
    bucket?: string;
    
    bucketOwner?: string;
    
    path?: string;
    
    packaging?: ReportPackagingType | string;
    
    encryptionKey?: string;
    
    encryptionDisabled?: boolean;
}
export declare namespace S3ReportExportConfig {
    
    const filterSensitiveLog: (obj: S3ReportExportConfig) => any;
}

export interface ReportExportConfig {
    
    exportConfigType?: ReportExportConfigType | string;
    
    s3Destination?: S3ReportExportConfig;
}
export declare namespace ReportExportConfig {
    
    const filterSensitiveLog: (obj: ReportExportConfig) => any;
}
export declare enum ReportGroupStatusType {
    ACTIVE = "ACTIVE",
    DELETING = "DELETING"
}
export declare enum ReportType {
    CODE_COVERAGE = "CODE_COVERAGE",
    TEST = "TEST"
}

export interface ReportGroup {
    
    arn?: string;
    
    name?: string;
    
    type?: ReportType | string;
    
    exportConfig?: ReportExportConfig;
    
    created?: Date;
    
    lastModified?: Date;
    
    tags?: Tag[];
    
    status?: ReportGroupStatusType | string;
}
export declare namespace ReportGroup {
    
    const filterSensitiveLog: (obj: ReportGroup) => any;
}
export interface BatchGetReportGroupsOutput {
    
    reportGroups?: ReportGroup[];
    
    reportGroupsNotFound?: string[];
}
export declare namespace BatchGetReportGroupsOutput {
    
    const filterSensitiveLog: (obj: BatchGetReportGroupsOutput) => any;
}
export interface BatchGetReportsInput {
    
    reportArns: string[] | undefined;
}
export declare namespace BatchGetReportsInput {
    
    const filterSensitiveLog: (obj: BatchGetReportsInput) => any;
}

export interface CodeCoverageReportSummary {
    
    lineCoveragePercentage?: number;
    
    linesCovered?: number;
    
    linesMissed?: number;
    
    branchCoveragePercentage?: number;
    
    branchesCovered?: number;
    
    branchesMissed?: number;
}
export declare namespace CodeCoverageReportSummary {
    
    const filterSensitiveLog: (obj: CodeCoverageReportSummary) => any;
}
export declare enum ReportStatusType {
    DELETING = "DELETING",
    FAILED = "FAILED",
    GENERATING = "GENERATING",
    INCOMPLETE = "INCOMPLETE",
    SUCCEEDED = "SUCCEEDED"
}

export interface TestReportSummary {
    
    total: number | undefined;
    
    statusCounts: {
        [key: string]: number;
    } | undefined;
    
    durationInNanoSeconds: number | undefined;
}
export declare namespace TestReportSummary {
    
    const filterSensitiveLog: (obj: TestReportSummary) => any;
}

export interface Report {
    
    arn?: string;
    
    type?: ReportType | string;
    
    name?: string;
    
    reportGroupArn?: string;
    
    executionId?: string;
    
    status?: ReportStatusType | string;
    
    created?: Date;
    
    expired?: Date;
    
    exportConfig?: ReportExportConfig;
    
    truncated?: boolean;
    
    testSummary?: TestReportSummary;
    
    codeCoverageSummary?: CodeCoverageReportSummary;
}
export declare namespace Report {
    
    const filterSensitiveLog: (obj: Report) => any;
}
export interface BatchGetReportsOutput {
    
    reports?: Report[];
    
    reportsNotFound?: string[];
}
export declare namespace BatchGetReportsOutput {
    
    const filterSensitiveLog: (obj: BatchGetReportsOutput) => any;
}

export interface BuildBatchFilter {
    
    status?: StatusType | string;
}
export declare namespace BuildBatchFilter {
    
    const filterSensitiveLog: (obj: BuildBatchFilter) => any;
}
export interface CreateProjectInput {
    
    name: string | undefined;
    
    description?: string;
    
    source: ProjectSource | undefined;
    
    secondarySources?: ProjectSource[];
    
    sourceVersion?: string;
    
    secondarySourceVersions?: ProjectSourceVersion[];
    
    artifacts: ProjectArtifacts | undefined;
    
    secondaryArtifacts?: ProjectArtifacts[];
    
    cache?: ProjectCache;
    
    environment: ProjectEnvironment | undefined;
    
    serviceRole: string | undefined;
    
    timeoutInMinutes?: number;
    
    queuedTimeoutInMinutes?: number;
    
    encryptionKey?: string;
    
    tags?: Tag[];
    
    vpcConfig?: VpcConfig;
    
    badgeEnabled?: boolean;
    
    logsConfig?: LogsConfig;
    
    fileSystemLocations?: ProjectFileSystemLocation[];
    
    buildBatchConfig?: ProjectBuildBatchConfig;
    
    concurrentBuildLimit?: number;
}
export declare namespace CreateProjectInput {
    
    const filterSensitiveLog: (obj: CreateProjectInput) => any;
}
export interface CreateProjectOutput {
    
    project?: Project;
}
export declare namespace CreateProjectOutput {
    
    const filterSensitiveLog: (obj: CreateProjectOutput) => any;
}

export interface ResourceAlreadyExistsException extends __SmithyException, $MetadataBearer {
    name: "ResourceAlreadyExistsException";
    $fault: "client";
    message?: string;
}
export declare namespace ResourceAlreadyExistsException {
    
    const filterSensitiveLog: (obj: ResourceAlreadyExistsException) => any;
}
export interface CreateReportGroupInput {
    
    name: string | undefined;
    
    type: ReportType | string | undefined;
    
    exportConfig: ReportExportConfig | undefined;
    
    tags?: Tag[];
}
export declare namespace CreateReportGroupInput {
    
    const filterSensitiveLog: (obj: CreateReportGroupInput) => any;
}
export interface CreateReportGroupOutput {
    
    reportGroup?: ReportGroup;
}
export declare namespace CreateReportGroupOutput {
    
    const filterSensitiveLog: (obj: CreateReportGroupOutput) => any;
}
export interface CreateWebhookInput {
    
    projectName: string | undefined;
    
    branchFilter?: string;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
}
export declare namespace CreateWebhookInput {
    
    const filterSensitiveLog: (obj: CreateWebhookInput) => any;
}
export interface CreateWebhookOutput {
    
    webhook?: Webhook;
}
export declare namespace CreateWebhookOutput {
    
    const filterSensitiveLog: (obj: CreateWebhookOutput) => any;
}

export interface OAuthProviderException extends __SmithyException, $MetadataBearer {
    name: "OAuthProviderException";
    $fault: "client";
    message?: string;
}
export declare namespace OAuthProviderException {
    
    const filterSensitiveLog: (obj: OAuthProviderException) => any;
}

export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
    name: "ResourceNotFoundException";
    $fault: "client";
    message?: string;
}
export declare namespace ResourceNotFoundException {
    
    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
}
export interface DeleteBuildBatchInput {
    
    id: string | undefined;
}
export declare namespace DeleteBuildBatchInput {
    
    const filterSensitiveLog: (obj: DeleteBuildBatchInput) => any;
}
export interface DeleteBuildBatchOutput {
    
    statusCode?: string;
    
    buildsDeleted?: string[];
    
    buildsNotDeleted?: BuildNotDeleted[];
}
export declare namespace DeleteBuildBatchOutput {
    
    const filterSensitiveLog: (obj: DeleteBuildBatchOutput) => any;
}
export interface DeleteProjectInput {
    
    name: string | undefined;
}
export declare namespace DeleteProjectInput {
    
    const filterSensitiveLog: (obj: DeleteProjectInput) => any;
}
export interface DeleteProjectOutput {
}
export declare namespace DeleteProjectOutput {
    
    const filterSensitiveLog: (obj: DeleteProjectOutput) => any;
}
export interface DeleteReportInput {
    
    arn: string | undefined;
}
export declare namespace DeleteReportInput {
    
    const filterSensitiveLog: (obj: DeleteReportInput) => any;
}
export interface DeleteReportOutput {
}
export declare namespace DeleteReportOutput {
    
    const filterSensitiveLog: (obj: DeleteReportOutput) => any;
}
export interface DeleteReportGroupInput {
    
    arn: string | undefined;
    
    deleteReports?: boolean;
}
export declare namespace DeleteReportGroupInput {
    
    const filterSensitiveLog: (obj: DeleteReportGroupInput) => any;
}
export interface DeleteReportGroupOutput {
}
export declare namespace DeleteReportGroupOutput {
    
    const filterSensitiveLog: (obj: DeleteReportGroupOutput) => any;
}
export interface DeleteResourcePolicyInput {
    
    resourceArn: string | undefined;
}
export declare namespace DeleteResourcePolicyInput {
    
    const filterSensitiveLog: (obj: DeleteResourcePolicyInput) => any;
}
export interface DeleteResourcePolicyOutput {
}
export declare namespace DeleteResourcePolicyOutput {
    
    const filterSensitiveLog: (obj: DeleteResourcePolicyOutput) => any;
}
export interface DeleteSourceCredentialsInput {
    
    arn: string | undefined;
}
export declare namespace DeleteSourceCredentialsInput {
    
    const filterSensitiveLog: (obj: DeleteSourceCredentialsInput) => any;
}
export interface DeleteSourceCredentialsOutput {
    
    arn?: string;
}
export declare namespace DeleteSourceCredentialsOutput {
    
    const filterSensitiveLog: (obj: DeleteSourceCredentialsOutput) => any;
}
export interface DeleteWebhookInput {
    
    projectName: string | undefined;
}
export declare namespace DeleteWebhookInput {
    
    const filterSensitiveLog: (obj: DeleteWebhookInput) => any;
}
export interface DeleteWebhookOutput {
}
export declare namespace DeleteWebhookOutput {
    
    const filterSensitiveLog: (obj: DeleteWebhookOutput) => any;
}
export declare enum ReportCodeCoverageSortByType {
    FILE_PATH = "FILE_PATH",
    LINE_COVERAGE_PERCENTAGE = "LINE_COVERAGE_PERCENTAGE"
}
export declare enum SortOrderType {
    ASCENDING = "ASCENDING",
    DESCENDING = "DESCENDING"
}
export interface DescribeCodeCoveragesInput {
    
    reportArn: string | undefined;
    
    nextToken?: string;
    
    maxResults?: number;
    
    sortOrder?: SortOrderType | string;
    
    sortBy?: ReportCodeCoverageSortByType | string;
    
    minLineCoveragePercentage?: number;
    
    maxLineCoveragePercentage?: number;
}
export declare namespace DescribeCodeCoveragesInput {
    
    const filterSensitiveLog: (obj: DescribeCodeCoveragesInput) => any;
}

export interface CodeCoverage {
    
    id?: string;
    
    reportARN?: string;
    
    filePath?: string;
    
    lineCoveragePercentage?: number;
    
    linesCovered?: number;
    
    linesMissed?: number;
    
    branchCoveragePercentage?: number;
    
    branchesCovered?: number;
    
    branchesMissed?: number;
    
    expired?: Date;
}
export declare namespace CodeCoverage {
    
    const filterSensitiveLog: (obj: CodeCoverage) => any;
}
export interface DescribeCodeCoveragesOutput {
    
    nextToken?: string;
    
    codeCoverages?: CodeCoverage[];
}
export declare namespace DescribeCodeCoveragesOutput {
    
    const filterSensitiveLog: (obj: DescribeCodeCoveragesOutput) => any;
}

export interface TestCaseFilter {
    
    status?: string;
    
    keyword?: string;
}
export declare namespace TestCaseFilter {
    
    const filterSensitiveLog: (obj: TestCaseFilter) => any;
}
export interface DescribeTestCasesInput {
    
    reportArn: string | undefined;
    
    nextToken?: string;
    
    maxResults?: number;
    
    filter?: TestCaseFilter;
}
export declare namespace DescribeTestCasesInput {
    
    const filterSensitiveLog: (obj: DescribeTestCasesInput) => any;
}

export interface TestCase {
    
    reportArn?: string;
    
    testRawDataPath?: string;
    
    prefix?: string;
    
    name?: string;
    
    status?: string;
    
    durationInNanoSeconds?: number;
    
    message?: string;
    
    expired?: Date;
}
export declare namespace TestCase {
    
    const filterSensitiveLog: (obj: TestCase) => any;
}
export interface DescribeTestCasesOutput {
    
    nextToken?: string;
    
    testCases?: TestCase[];
}
export declare namespace DescribeTestCasesOutput {
    
    const filterSensitiveLog: (obj: DescribeTestCasesOutput) => any;
}
export declare enum ReportGroupTrendFieldType {
    BRANCHES_COVERED = "BRANCHES_COVERED",
    BRANCHES_MISSED = "BRANCHES_MISSED",
    BRANCH_COVERAGE = "BRANCH_COVERAGE",
    DURATION = "DURATION",
    LINES_COVERED = "LINES_COVERED",
    LINES_MISSED = "LINES_MISSED",
    LINE_COVERAGE = "LINE_COVERAGE",
    PASS_RATE = "PASS_RATE",
    TOTAL = "TOTAL"
}
export interface GetReportGroupTrendInput {
    
    reportGroupArn: string | undefined;
    
    numOfReports?: number;
    
    trendField: ReportGroupTrendFieldType | string | undefined;
}
export declare namespace GetReportGroupTrendInput {
    
    const filterSensitiveLog: (obj: GetReportGroupTrendInput) => any;
}

export interface ReportWithRawData {
    
    reportArn?: string;
    
    data?: string;
}
export declare namespace ReportWithRawData {
    
    const filterSensitiveLog: (obj: ReportWithRawData) => any;
}

export interface ReportGroupTrendStats {
    
    average?: string;
    
    max?: string;
    
    min?: string;
}
export declare namespace ReportGroupTrendStats {
    
    const filterSensitiveLog: (obj: ReportGroupTrendStats) => any;
}
export interface GetReportGroupTrendOutput {
    
    stats?: ReportGroupTrendStats;
    
    rawData?: ReportWithRawData[];
}
export declare namespace GetReportGroupTrendOutput {
    
    const filterSensitiveLog: (obj: GetReportGroupTrendOutput) => any;
}
export interface GetResourcePolicyInput {
    
    resourceArn: string | undefined;
}
export declare namespace GetResourcePolicyInput {
    
    const filterSensitiveLog: (obj: GetResourcePolicyInput) => any;
}
export interface GetResourcePolicyOutput {
    
    policy?: string;
}
export declare namespace GetResourcePolicyOutput {
    
    const filterSensitiveLog: (obj: GetResourcePolicyOutput) => any;
}
export declare enum ServerType {
    BITBUCKET = "BITBUCKET",
    GITHUB = "GITHUB",
    GITHUB_ENTERPRISE = "GITHUB_ENTERPRISE"
}
export interface ImportSourceCredentialsInput {
    
    username?: string;
    
    token: string | undefined;
    
    serverType: ServerType | string | undefined;
    
    authType: AuthType | string | undefined;
    
    shouldOverwrite?: boolean;
}
export declare namespace ImportSourceCredentialsInput {
    
    const filterSensitiveLog: (obj: ImportSourceCredentialsInput) => any;
}
export interface ImportSourceCredentialsOutput {
    
    arn?: string;
}
export declare namespace ImportSourceCredentialsOutput {
    
    const filterSensitiveLog: (obj: ImportSourceCredentialsOutput) => any;
}
export interface InvalidateProjectCacheInput {
    
    projectName: string | undefined;
}
export declare namespace InvalidateProjectCacheInput {
    
    const filterSensitiveLog: (obj: InvalidateProjectCacheInput) => any;
}
export interface InvalidateProjectCacheOutput {
}
export declare namespace InvalidateProjectCacheOutput {
    
    const filterSensitiveLog: (obj: InvalidateProjectCacheOutput) => any;
}
export interface ListBuildBatchesInput {
    
    filter?: BuildBatchFilter;
    
    maxResults?: number;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export declare namespace ListBuildBatchesInput {
    
    const filterSensitiveLog: (obj: ListBuildBatchesInput) => any;
}
export interface ListBuildBatchesOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export declare namespace ListBuildBatchesOutput {
    
    const filterSensitiveLog: (obj: ListBuildBatchesOutput) => any;
}
export interface ListBuildBatchesForProjectInput {
    
    projectName?: string;
    
    filter?: BuildBatchFilter;
    
    maxResults?: number;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export declare namespace ListBuildBatchesForProjectInput {
    
    const filterSensitiveLog: (obj: ListBuildBatchesForProjectInput) => any;
}
export interface ListBuildBatchesForProjectOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export declare namespace ListBuildBatchesForProjectOutput {
    
    const filterSensitiveLog: (obj: ListBuildBatchesForProjectOutput) => any;
}
export interface ListBuildsInput {
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export declare namespace ListBuildsInput {
    
    const filterSensitiveLog: (obj: ListBuildsInput) => any;
}
export interface ListBuildsOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export declare namespace ListBuildsOutput {
    
    const filterSensitiveLog: (obj: ListBuildsOutput) => any;
}
export interface ListBuildsForProjectInput {
    
    projectName: string | undefined;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export declare namespace ListBuildsForProjectInput {
    
    const filterSensitiveLog: (obj: ListBuildsForProjectInput) => any;
}
export interface ListBuildsForProjectOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export declare namespace ListBuildsForProjectOutput {
    
    const filterSensitiveLog: (obj: ListBuildsForProjectOutput) => any;
}
export interface ListCuratedEnvironmentImagesInput {
}
export declare namespace ListCuratedEnvironmentImagesInput {
    
    const filterSensitiveLog: (obj: ListCuratedEnvironmentImagesInput) => any;
}

export interface EnvironmentImage {
    
    name?: string;
    
    description?: string;
    
    versions?: string[];
}
export declare namespace EnvironmentImage {
    
    const filterSensitiveLog: (obj: EnvironmentImage) => any;
}
export declare enum LanguageType {
    ANDROID = "ANDROID",
    BASE = "BASE",
    DOCKER = "DOCKER",
    DOTNET = "DOTNET",
    GOLANG = "GOLANG",
    JAVA = "JAVA",
    NODE_JS = "NODE_JS",
    PHP = "PHP",
    PYTHON = "PYTHON",
    RUBY = "RUBY"
}

export interface EnvironmentLanguage {
    
    language?: LanguageType | string;
    
    images?: EnvironmentImage[];
}
export declare namespace EnvironmentLanguage {
    
    const filterSensitiveLog: (obj: EnvironmentLanguage) => any;
}
export declare enum PlatformType {
    AMAZON_LINUX = "AMAZON_LINUX",
    DEBIAN = "DEBIAN",
    UBUNTU = "UBUNTU",
    WINDOWS_SERVER = "WINDOWS_SERVER"
}

export interface EnvironmentPlatform {
    
    platform?: PlatformType | string;
    
    languages?: EnvironmentLanguage[];
}
export declare namespace EnvironmentPlatform {
    
    const filterSensitiveLog: (obj: EnvironmentPlatform) => any;
}
export interface ListCuratedEnvironmentImagesOutput {
    
    platforms?: EnvironmentPlatform[];
}
export declare namespace ListCuratedEnvironmentImagesOutput {
    
    const filterSensitiveLog: (obj: ListCuratedEnvironmentImagesOutput) => any;
}
export declare enum ProjectSortByType {
    CREATED_TIME = "CREATED_TIME",
    LAST_MODIFIED_TIME = "LAST_MODIFIED_TIME",
    NAME = "NAME"
}
export interface ListProjectsInput {
    
    sortBy?: ProjectSortByType | string;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export declare namespace ListProjectsInput {
    
    const filterSensitiveLog: (obj: ListProjectsInput) => any;
}
export interface ListProjectsOutput {
    
    nextToken?: string;
    
    projects?: string[];
}
export declare namespace ListProjectsOutput {
    
    const filterSensitiveLog: (obj: ListProjectsOutput) => any;
}
export declare enum ReportGroupSortByType {
    CREATED_TIME = "CREATED_TIME",
    LAST_MODIFIED_TIME = "LAST_MODIFIED_TIME",
    NAME = "NAME"
}
export interface ListReportGroupsInput {
    
    sortOrder?: SortOrderType | string;
    
    sortBy?: ReportGroupSortByType | string;
    
    nextToken?: string;
    
    maxResults?: number;
}
export declare namespace ListReportGroupsInput {
    
    const filterSensitiveLog: (obj: ListReportGroupsInput) => any;
}
export interface ListReportGroupsOutput {
    
    nextToken?: string;
    
    reportGroups?: string[];
}
export declare namespace ListReportGroupsOutput {
    
    const filterSensitiveLog: (obj: ListReportGroupsOutput) => any;
}

export interface ReportFilter {
    
    status?: ReportStatusType | string;
}
export declare namespace ReportFilter {
    
    const filterSensitiveLog: (obj: ReportFilter) => any;
}
export interface ListReportsInput {
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
    
    maxResults?: number;
    
    filter?: ReportFilter;
}
export declare namespace ListReportsInput {
    
    const filterSensitiveLog: (obj: ListReportsInput) => any;
}
export interface ListReportsOutput {
    
    nextToken?: string;
    
    reports?: string[];
}
export declare namespace ListReportsOutput {
    
    const filterSensitiveLog: (obj: ListReportsOutput) => any;
}
export interface ListReportsForReportGroupInput {
    
    reportGroupArn: string | undefined;
    
    nextToken?: string;
    
    sortOrder?: SortOrderType | string;
    
    maxResults?: number;
    
    filter?: ReportFilter;
}
export declare namespace ListReportsForReportGroupInput {
    
    const filterSensitiveLog: (obj: ListReportsForReportGroupInput) => any;
}
export interface ListReportsForReportGroupOutput {
    
    nextToken?: string;
    
    reports?: string[];
}
export declare namespace ListReportsForReportGroupOutput {
    
    const filterSensitiveLog: (obj: ListReportsForReportGroupOutput) => any;
}
export declare enum SharedResourceSortByType {
    ARN = "ARN",
    MODIFIED_TIME = "MODIFIED_TIME"
}
export interface ListSharedProjectsInput {
    
    sortBy?: SharedResourceSortByType | string;
    
    sortOrder?: SortOrderType | string;
    
    maxResults?: number;
    
    nextToken?: string;
}
export declare namespace ListSharedProjectsInput {
    
    const filterSensitiveLog: (obj: ListSharedProjectsInput) => any;
}
export interface ListSharedProjectsOutput {
    
    nextToken?: string;
    
    projects?: string[];
}
export declare namespace ListSharedProjectsOutput {
    
    const filterSensitiveLog: (obj: ListSharedProjectsOutput) => any;
}
export interface ListSharedReportGroupsInput {
    
    sortOrder?: SortOrderType | string;
    
    sortBy?: SharedResourceSortByType | string;
    
    nextToken?: string;
    
    maxResults?: number;
}
export declare namespace ListSharedReportGroupsInput {
    
    const filterSensitiveLog: (obj: ListSharedReportGroupsInput) => any;
}
export interface ListSharedReportGroupsOutput {
    
    nextToken?: string;
    
    reportGroups?: string[];
}
export declare namespace ListSharedReportGroupsOutput {
    
    const filterSensitiveLog: (obj: ListSharedReportGroupsOutput) => any;
}
export interface ListSourceCredentialsInput {
}
export declare namespace ListSourceCredentialsInput {
    
    const filterSensitiveLog: (obj: ListSourceCredentialsInput) => any;
}

export interface SourceCredentialsInfo {
    
    arn?: string;
    
    serverType?: ServerType | string;
    
    authType?: AuthType | string;
}
export declare namespace SourceCredentialsInfo {
    
    const filterSensitiveLog: (obj: SourceCredentialsInfo) => any;
}
export interface ListSourceCredentialsOutput {
    
    sourceCredentialsInfos?: SourceCredentialsInfo[];
}
export declare namespace ListSourceCredentialsOutput {
    
    const filterSensitiveLog: (obj: ListSourceCredentialsOutput) => any;
}
export interface PutResourcePolicyInput {
    
    policy: string | undefined;
    
    resourceArn: string | undefined;
}
export declare namespace PutResourcePolicyInput {
    
    const filterSensitiveLog: (obj: PutResourcePolicyInput) => any;
}
export interface PutResourcePolicyOutput {
    
    resourceArn?: string;
}
export declare namespace PutResourcePolicyOutput {
    
    const filterSensitiveLog: (obj: PutResourcePolicyOutput) => any;
}
export interface RetryBuildInput {
    
    id?: string;
    
    idempotencyToken?: string;
}
export declare namespace RetryBuildInput {
    
    const filterSensitiveLog: (obj: RetryBuildInput) => any;
}
export interface RetryBuildOutput {
    
    build?: Build;
}
export declare namespace RetryBuildOutput {
    
    const filterSensitiveLog: (obj: RetryBuildOutput) => any;
}
export declare enum RetryBuildBatchType {
    RETRY_ALL_BUILDS = "RETRY_ALL_BUILDS",
    RETRY_FAILED_BUILDS = "RETRY_FAILED_BUILDS"
}
export interface RetryBuildBatchInput {
    
    id?: string;
    
    idempotencyToken?: string;
    
    retryType?: RetryBuildBatchType | string;
}
export declare namespace RetryBuildBatchInput {
    
    const filterSensitiveLog: (obj: RetryBuildBatchInput) => any;
}
export interface RetryBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
export declare namespace RetryBuildBatchOutput {
    
    const filterSensitiveLog: (obj: RetryBuildBatchOutput) => any;
}
export interface StartBuildInput {
    
    projectName: string | undefined;
    
    secondarySourcesOverride?: ProjectSource[];
    
    secondarySourcesVersionOverride?: ProjectSourceVersion[];
    
    sourceVersion?: string;
    
    artifactsOverride?: ProjectArtifacts;
    
    secondaryArtifactsOverride?: ProjectArtifacts[];
    
    environmentVariablesOverride?: EnvironmentVariable[];
    
    sourceTypeOverride?: SourceType | string;
    
    sourceLocationOverride?: string;
    
    sourceAuthOverride?: SourceAuth;
    
    gitCloneDepthOverride?: number;
    
    gitSubmodulesConfigOverride?: GitSubmodulesConfig;
    
    buildspecOverride?: string;
    
    insecureSslOverride?: boolean;
    
    reportBuildStatusOverride?: boolean;
    
    buildStatusConfigOverride?: BuildStatusConfig;
    
    environmentTypeOverride?: EnvironmentType | string;
    
    imageOverride?: string;
    
    computeTypeOverride?: ComputeType | string;
    
    certificateOverride?: string;
    
    cacheOverride?: ProjectCache;
    
    serviceRoleOverride?: string;
    
    privilegedModeOverride?: boolean;
    
    timeoutInMinutesOverride?: number;
    
    queuedTimeoutInMinutesOverride?: number;
    
    encryptionKeyOverride?: string;
    
    idempotencyToken?: string;
    
    logsConfigOverride?: LogsConfig;
    
    registryCredentialOverride?: RegistryCredential;
    
    imagePullCredentialsTypeOverride?: ImagePullCredentialsType | string;
    
    debugSessionEnabled?: boolean;
}
export declare namespace StartBuildInput {
    
    const filterSensitiveLog: (obj: StartBuildInput) => any;
}
export interface StartBuildOutput {
    
    build?: Build;
}
export declare namespace StartBuildOutput {
    
    const filterSensitiveLog: (obj: StartBuildOutput) => any;
}
export interface StartBuildBatchInput {
    
    projectName: string | undefined;
    
    secondarySourcesOverride?: ProjectSource[];
    
    secondarySourcesVersionOverride?: ProjectSourceVersion[];
    
    sourceVersion?: string;
    
    artifactsOverride?: ProjectArtifacts;
    
    secondaryArtifactsOverride?: ProjectArtifacts[];
    
    environmentVariablesOverride?: EnvironmentVariable[];
    
    sourceTypeOverride?: SourceType | string;
    
    sourceLocationOverride?: string;
    
    sourceAuthOverride?: SourceAuth;
    
    gitCloneDepthOverride?: number;
    
    gitSubmodulesConfigOverride?: GitSubmodulesConfig;
    
    buildspecOverride?: string;
    
    insecureSslOverride?: boolean;
    
    reportBuildBatchStatusOverride?: boolean;
    
    environmentTypeOverride?: EnvironmentType | string;
    
    imageOverride?: string;
    
    computeTypeOverride?: ComputeType | string;
    
    certificateOverride?: string;
    
    cacheOverride?: ProjectCache;
    
    serviceRoleOverride?: string;
    
    privilegedModeOverride?: boolean;
    
    buildTimeoutInMinutesOverride?: number;
    
    queuedTimeoutInMinutesOverride?: number;
    
    encryptionKeyOverride?: string;
    
    idempotencyToken?: string;
    
    logsConfigOverride?: LogsConfig;
    
    registryCredentialOverride?: RegistryCredential;
    
    imagePullCredentialsTypeOverride?: ImagePullCredentialsType | string;
    
    buildBatchConfigOverride?: ProjectBuildBatchConfig;
    
    debugSessionEnabled?: boolean;
}
export declare namespace StartBuildBatchInput {
    
    const filterSensitiveLog: (obj: StartBuildBatchInput) => any;
}
export interface StartBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
export declare namespace StartBuildBatchOutput {
    
    const filterSensitiveLog: (obj: StartBuildBatchOutput) => any;
}
export interface StopBuildInput {
    
    id: string | undefined;
}
export declare namespace StopBuildInput {
    
    const filterSensitiveLog: (obj: StopBuildInput) => any;
}
export interface StopBuildOutput {
    
    build?: Build;
}
export declare namespace StopBuildOutput {
    
    const filterSensitiveLog: (obj: StopBuildOutput) => any;
}
export interface StopBuildBatchInput {
    
    id: string | undefined;
}
export declare namespace StopBuildBatchInput {
    
    const filterSensitiveLog: (obj: StopBuildBatchInput) => any;
}
export interface StopBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
export declare namespace StopBuildBatchOutput {
    
    const filterSensitiveLog: (obj: StopBuildBatchOutput) => any;
}
export interface UpdateProjectInput {
    
    name: string | undefined;
    
    description?: string;
    
    source?: ProjectSource;
    
    secondarySources?: ProjectSource[];
    
    sourceVersion?: string;
    
    secondarySourceVersions?: ProjectSourceVersion[];
    
    artifacts?: ProjectArtifacts;
    
    secondaryArtifacts?: ProjectArtifacts[];
    
    cache?: ProjectCache;
    
    environment?: ProjectEnvironment;
    
    serviceRole?: string;
    
    timeoutInMinutes?: number;
    
    queuedTimeoutInMinutes?: number;
    
    encryptionKey?: string;
    
    tags?: Tag[];
    
    vpcConfig?: VpcConfig;
    
    badgeEnabled?: boolean;
    
    logsConfig?: LogsConfig;
    
    fileSystemLocations?: ProjectFileSystemLocation[];
    
    buildBatchConfig?: ProjectBuildBatchConfig;
    
    concurrentBuildLimit?: number;
}
export declare namespace UpdateProjectInput {
    
    const filterSensitiveLog: (obj: UpdateProjectInput) => any;
}
export interface UpdateProjectOutput {
    
    project?: Project;
}
export declare namespace UpdateProjectOutput {
    
    const filterSensitiveLog: (obj: UpdateProjectOutput) => any;
}
export interface UpdateProjectVisibilityInput {
    
    projectArn: string | undefined;
    
    projectVisibility: ProjectVisibilityType | string | undefined;
    
    resourceAccessRole?: string;
}
export declare namespace UpdateProjectVisibilityInput {
    
    const filterSensitiveLog: (obj: UpdateProjectVisibilityInput) => any;
}
export interface UpdateProjectVisibilityOutput {
    
    projectArn?: string;
    
    publicProjectAlias?: string;
    
    projectVisibility?: ProjectVisibilityType | string;
}
export declare namespace UpdateProjectVisibilityOutput {
    
    const filterSensitiveLog: (obj: UpdateProjectVisibilityOutput) => any;
}
export interface UpdateReportGroupInput {
    
    arn: string | undefined;
    
    exportConfig?: ReportExportConfig;
    
    tags?: Tag[];
}
export declare namespace UpdateReportGroupInput {
    
    const filterSensitiveLog: (obj: UpdateReportGroupInput) => any;
}
export interface UpdateReportGroupOutput {
    
    reportGroup?: ReportGroup;
}
export declare namespace UpdateReportGroupOutput {
    
    const filterSensitiveLog: (obj: UpdateReportGroupOutput) => any;
}
export interface UpdateWebhookInput {
    
    projectName: string | undefined;
    
    branchFilter?: string;
    
    rotateSecret?: boolean;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
}
export declare namespace UpdateWebhookInput {
    
    const filterSensitiveLog: (obj: UpdateWebhookInput) => any;
}
export interface UpdateWebhookOutput {
    
    webhook?: Webhook;
}
export declare namespace UpdateWebhookOutput {
    
    const filterSensitiveLog: (obj: UpdateWebhookOutput) => any;
}
