import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
import { CodeBuildServiceException as __BaseException } from "./CodeBuildServiceException";

export declare class AccountLimitExceededException extends __BaseException {
    readonly name: "AccountLimitExceededException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<AccountLimitExceededException, __BaseException>);
}
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 interface BuildNotDeleted {
    
    id?: string;
    
    statusCode?: string;
}
export interface BatchDeleteBuildsOutput {
    
    buildsDeleted?: string[];
    
    buildsNotDeleted?: BuildNotDeleted[];
}

export declare class InvalidInputException extends __BaseException {
    readonly name: "InvalidInputException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<InvalidInputException, __BaseException>);
}
export interface BatchGetBuildBatchesInput {
    
    ids: string[] | undefined;
}
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 enum BatchReportModeType {
    REPORT_AGGREGATED_BATCH = "REPORT_AGGREGATED_BATCH",
    REPORT_INDIVIDUAL_BUILDS = "REPORT_INDIVIDUAL_BUILDS"
}

export interface BatchRestrictions {
    
    maximumBuildsAllowed?: number;
    
    computeTypesAllowed?: string[];
}

export interface ProjectBuildBatchConfig {
    
    serviceRole?: string;
    
    combineArtifacts?: boolean;
    
    restrictions?: BatchRestrictions;
    
    timeoutInMins?: number;
    
    batchReportMode?: BatchReportModeType | string;
}
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 interface BuildSummary {
    
    arn?: string;
    
    requestedOn?: Date;
    
    buildStatus?: StatusType | string;
    
    primaryArtifact?: ResolvedArtifact;
    
    secondaryArtifacts?: ResolvedArtifact[];
}

export interface BuildGroup {
    
    identifier?: string;
    
    dependsOn?: string[];
    
    ignoreFailure?: boolean;
    
    currentBuildSummary?: BuildSummary;
    
    priorBuildSummaryList?: BuildSummary[];
}
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 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 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 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 enum FileSystemType {
    EFS = "EFS"
}

export interface ProjectFileSystemLocation {
    
    type?: FileSystemType | string;
    
    location?: string;
    
    mountPoint?: string;
    
    identifier?: string;
    
    mountOptions?: string;
}
export declare enum LogsConfigStatusType {
    DISABLED = "DISABLED",
    ENABLED = "ENABLED"
}

export interface CloudWatchLogsConfig {
    
    status: LogsConfigStatusType | string | undefined;
    
    groupName?: string;
    
    streamName?: string;
}

export interface S3LogsConfig {
    
    status: LogsConfigStatusType | string | undefined;
    
    location?: string;
    
    encryptionDisabled?: boolean;
    
    bucketOwnerAccess?: BucketOwnerAccess | string;
}

export interface LogsConfig {
    
    cloudWatchLogs?: CloudWatchLogsConfig;
    
    s3Logs?: S3LogsConfig;
}

export interface PhaseContext {
    
    statusCode?: string;
    
    message?: string;
}
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 enum SourceAuthType {
    OAUTH = "OAUTH"
}

export interface SourceAuth {
    
    type: SourceAuthType | string | undefined;
    
    resource?: string;
}

export interface BuildStatusConfig {
    
    context?: string;
    
    targetUrl?: string;
}

export interface GitSubmodulesConfig {
    
    fetchSubmodules: boolean | undefined;
}
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 interface ProjectSourceVersion {
    
    sourceIdentifier: string | undefined;
    
    sourceVersion: string | undefined;
}

export interface VpcConfig {
    
    vpcId?: string;
    
    subnets?: string[];
    
    securityGroupIds?: string[];
}

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 interface BatchGetBuildBatchesOutput {
    
    buildBatches?: BuildBatch[];
    
    buildBatchesNotFound?: string[];
}
export interface BatchGetBuildsInput {
    
    ids: string[] | undefined;
}

export interface DebugSession {
    
    sessionEnabled?: boolean;
    
    sessionTarget?: string;
}

export interface ExportedEnvironmentVariable {
    
    name?: string;
    
    value?: string;
}

export interface LogsLocation {
    
    groupName?: string;
    
    streamName?: string;
    
    deepLink?: string;
    
    s3DeepLink?: string;
    
    cloudWatchLogsArn?: string;
    
    s3LogsArn?: string;
    
    cloudWatchLogs?: CloudWatchLogsConfig;
    
    s3Logs?: S3LogsConfig;
}

export interface NetworkInterface {
    
    subnetId?: string;
    
    networkInterfaceId?: string;
}
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 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 interface BatchGetBuildsOutput {
    
    builds?: Build[];
    
    buildsNotFound?: string[];
}
export interface BatchGetProjectsInput {
    
    names: string[] | undefined;
}

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 interface ProjectBadge {
    
    badgeEnabled?: boolean;
    
    badgeRequestUrl?: string;
}
export declare enum ProjectVisibilityType {
    PRIVATE = "PRIVATE",
    PUBLIC_READ = "PUBLIC_READ"
}

export interface Tag {
    
    key?: string;
    
    value?: string;
}
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 interface Webhook {
    
    url?: string;
    
    payloadUrl?: string;
    
    secret?: string;
    
    branchFilter?: string;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
    
    lastModifiedSecret?: Date;
}

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 interface BatchGetProjectsOutput {
    
    projects?: Project[];
    
    projectsNotFound?: string[];
}
export interface BatchGetReportGroupsInput {
    
    reportGroupArns: string[] | undefined;
}
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 interface ReportExportConfig {
    
    exportConfigType?: ReportExportConfigType | string;
    
    s3Destination?: S3ReportExportConfig;
}
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 interface BatchGetReportGroupsOutput {
    
    reportGroups?: ReportGroup[];
    
    reportGroupsNotFound?: string[];
}
export interface BatchGetReportsInput {
    
    reportArns: string[] | undefined;
}

export interface CodeCoverageReportSummary {
    
    lineCoveragePercentage?: number;
    
    linesCovered?: number;
    
    linesMissed?: number;
    
    branchCoveragePercentage?: number;
    
    branchesCovered?: number;
    
    branchesMissed?: number;
}
export declare enum ReportStatusType {
    DELETING = "DELETING",
    FAILED = "FAILED",
    GENERATING = "GENERATING",
    INCOMPLETE = "INCOMPLETE",
    SUCCEEDED = "SUCCEEDED"
}

export interface TestReportSummary {
    
    total: number | undefined;
    
    statusCounts: Record<string, number> | undefined;
    
    durationInNanoSeconds: number | undefined;
}

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 interface BatchGetReportsOutput {
    
    reports?: Report[];
    
    reportsNotFound?: string[];
}

export interface BuildBatchFilter {
    
    status?: StatusType | string;
}
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 interface CreateProjectOutput {
    
    project?: Project;
}

export declare class ResourceAlreadyExistsException extends __BaseException {
    readonly name: "ResourceAlreadyExistsException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
}
export interface CreateReportGroupInput {
    
    name: string | undefined;
    
    type: ReportType | string | undefined;
    
    exportConfig: ReportExportConfig | undefined;
    
    tags?: Tag[];
}
export interface CreateReportGroupOutput {
    
    reportGroup?: ReportGroup;
}
export interface CreateWebhookInput {
    
    projectName: string | undefined;
    
    branchFilter?: string;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
}
export interface CreateWebhookOutput {
    
    webhook?: Webhook;
}

export declare class OAuthProviderException extends __BaseException {
    readonly name: "OAuthProviderException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<OAuthProviderException, __BaseException>);
}

export declare class ResourceNotFoundException extends __BaseException {
    readonly name: "ResourceNotFoundException";
    readonly $fault: "client";
    
    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
}
export interface DeleteBuildBatchInput {
    
    id: string | undefined;
}
export interface DeleteBuildBatchOutput {
    
    statusCode?: string;
    
    buildsDeleted?: string[];
    
    buildsNotDeleted?: BuildNotDeleted[];
}
export interface DeleteProjectInput {
    
    name: string | undefined;
}
export interface DeleteProjectOutput {
}
export interface DeleteReportInput {
    
    arn: string | undefined;
}
export interface DeleteReportOutput {
}
export interface DeleteReportGroupInput {
    
    arn: string | undefined;
    
    deleteReports?: boolean;
}
export interface DeleteReportGroupOutput {
}
export interface DeleteResourcePolicyInput {
    
    resourceArn: string | undefined;
}
export interface DeleteResourcePolicyOutput {
}
export interface DeleteSourceCredentialsInput {
    
    arn: string | undefined;
}
export interface DeleteSourceCredentialsOutput {
    
    arn?: string;
}
export interface DeleteWebhookInput {
    
    projectName: string | undefined;
}
export interface DeleteWebhookOutput {
}
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 interface CodeCoverage {
    
    id?: string;
    
    reportARN?: string;
    
    filePath?: string;
    
    lineCoveragePercentage?: number;
    
    linesCovered?: number;
    
    linesMissed?: number;
    
    branchCoveragePercentage?: number;
    
    branchesCovered?: number;
    
    branchesMissed?: number;
    
    expired?: Date;
}
export interface DescribeCodeCoveragesOutput {
    
    nextToken?: string;
    
    codeCoverages?: CodeCoverage[];
}

export interface TestCaseFilter {
    
    status?: string;
    
    keyword?: string;
}
export interface DescribeTestCasesInput {
    
    reportArn: string | undefined;
    
    nextToken?: string;
    
    maxResults?: number;
    
    filter?: TestCaseFilter;
}

export interface TestCase {
    
    reportArn?: string;
    
    testRawDataPath?: string;
    
    prefix?: string;
    
    name?: string;
    
    status?: string;
    
    durationInNanoSeconds?: number;
    
    message?: string;
    
    expired?: Date;
}
export interface DescribeTestCasesOutput {
    
    nextToken?: string;
    
    testCases?: TestCase[];
}
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 interface ReportWithRawData {
    
    reportArn?: string;
    
    data?: string;
}

export interface ReportGroupTrendStats {
    
    average?: string;
    
    max?: string;
    
    min?: string;
}
export interface GetReportGroupTrendOutput {
    
    stats?: ReportGroupTrendStats;
    
    rawData?: ReportWithRawData[];
}
export interface GetResourcePolicyInput {
    
    resourceArn: string | undefined;
}
export interface GetResourcePolicyOutput {
    
    policy?: string;
}
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 interface ImportSourceCredentialsOutput {
    
    arn?: string;
}
export interface InvalidateProjectCacheInput {
    
    projectName: string | undefined;
}
export interface InvalidateProjectCacheOutput {
}
export interface ListBuildBatchesInput {
    
    filter?: BuildBatchFilter;
    
    maxResults?: number;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export interface ListBuildBatchesOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export interface ListBuildBatchesForProjectInput {
    
    projectName?: string;
    
    filter?: BuildBatchFilter;
    
    maxResults?: number;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export interface ListBuildBatchesForProjectOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export interface ListBuildsInput {
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export interface ListBuildsOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export interface ListBuildsForProjectInput {
    
    projectName: string | undefined;
    
    sortOrder?: SortOrderType | string;
    
    nextToken?: string;
}
export interface ListBuildsForProjectOutput {
    
    ids?: string[];
    
    nextToken?: string;
}
export interface ListCuratedEnvironmentImagesInput {
}

export interface EnvironmentImage {
    
    name?: string;
    
    description?: string;
    
    versions?: string[];
}
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 enum PlatformType {
    AMAZON_LINUX = "AMAZON_LINUX",
    DEBIAN = "DEBIAN",
    UBUNTU = "UBUNTU",
    WINDOWS_SERVER = "WINDOWS_SERVER"
}

export interface EnvironmentPlatform {
    
    platform?: PlatformType | string;
    
    languages?: EnvironmentLanguage[];
}
export interface ListCuratedEnvironmentImagesOutput {
    
    platforms?: EnvironmentPlatform[];
}
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 interface ListProjectsOutput {
    
    nextToken?: string;
    
    projects?: string[];
}
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 interface ListReportGroupsOutput {
    
    nextToken?: string;
    
    reportGroups?: string[];
}

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

export interface SourceCredentialsInfo {
    
    arn?: string;
    
    serverType?: ServerType | string;
    
    authType?: AuthType | string;
}
export interface ListSourceCredentialsOutput {
    
    sourceCredentialsInfos?: SourceCredentialsInfo[];
}
export interface PutResourcePolicyInput {
    
    policy: string | undefined;
    
    resourceArn: string | undefined;
}
export interface PutResourcePolicyOutput {
    
    resourceArn?: string;
}
export interface RetryBuildInput {
    
    id?: string;
    
    idempotencyToken?: string;
}
export interface RetryBuildOutput {
    
    build?: Build;
}
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 interface RetryBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
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 interface StartBuildOutput {
    
    build?: Build;
}
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 interface StartBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
export interface StopBuildInput {
    
    id: string | undefined;
}
export interface StopBuildOutput {
    
    build?: Build;
}
export interface StopBuildBatchInput {
    
    id: string | undefined;
}
export interface StopBuildBatchOutput {
    
    buildBatch?: BuildBatch;
}
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 interface UpdateProjectOutput {
    
    project?: Project;
}
export interface UpdateProjectVisibilityInput {
    
    projectArn: string | undefined;
    
    projectVisibility: ProjectVisibilityType | string | undefined;
    
    resourceAccessRole?: string;
}
export interface UpdateProjectVisibilityOutput {
    
    projectArn?: string;
    
    publicProjectAlias?: string;
    
    projectVisibility?: ProjectVisibilityType | string;
}
export interface UpdateReportGroupInput {
    
    arn: string | undefined;
    
    exportConfig?: ReportExportConfig;
    
    tags?: Tag[];
}
export interface UpdateReportGroupOutput {
    
    reportGroup?: ReportGroup;
}
export interface UpdateWebhookInput {
    
    projectName: string | undefined;
    
    branchFilter?: string;
    
    rotateSecret?: boolean;
    
    filterGroups?: WebhookFilter[][];
    
    buildType?: WebhookBuildType | string;
}
export interface UpdateWebhookOutput {
    
    webhook?: Webhook;
}

export declare const BatchDeleteBuildsInputFilterSensitiveLog: (obj: BatchDeleteBuildsInput) => any;

export declare const BuildNotDeletedFilterSensitiveLog: (obj: BuildNotDeleted) => any;

export declare const BatchDeleteBuildsOutputFilterSensitiveLog: (obj: BatchDeleteBuildsOutput) => any;

export declare const BatchGetBuildBatchesInputFilterSensitiveLog: (obj: BatchGetBuildBatchesInput) => any;

export declare const BuildArtifactsFilterSensitiveLog: (obj: BuildArtifacts) => any;

export declare const BatchRestrictionsFilterSensitiveLog: (obj: BatchRestrictions) => any;

export declare const ProjectBuildBatchConfigFilterSensitiveLog: (obj: ProjectBuildBatchConfig) => any;

export declare const ResolvedArtifactFilterSensitiveLog: (obj: ResolvedArtifact) => any;

export declare const BuildSummaryFilterSensitiveLog: (obj: BuildSummary) => any;

export declare const BuildGroupFilterSensitiveLog: (obj: BuildGroup) => any;

export declare const ProjectCacheFilterSensitiveLog: (obj: ProjectCache) => any;

export declare const EnvironmentVariableFilterSensitiveLog: (obj: EnvironmentVariable) => any;

export declare const RegistryCredentialFilterSensitiveLog: (obj: RegistryCredential) => any;

export declare const ProjectEnvironmentFilterSensitiveLog: (obj: ProjectEnvironment) => any;

export declare const ProjectFileSystemLocationFilterSensitiveLog: (obj: ProjectFileSystemLocation) => any;

export declare const CloudWatchLogsConfigFilterSensitiveLog: (obj: CloudWatchLogsConfig) => any;

export declare const S3LogsConfigFilterSensitiveLog: (obj: S3LogsConfig) => any;

export declare const LogsConfigFilterSensitiveLog: (obj: LogsConfig) => any;

export declare const PhaseContextFilterSensitiveLog: (obj: PhaseContext) => any;

export declare const BuildBatchPhaseFilterSensitiveLog: (obj: BuildBatchPhase) => any;

export declare const SourceAuthFilterSensitiveLog: (obj: SourceAuth) => any;

export declare const BuildStatusConfigFilterSensitiveLog: (obj: BuildStatusConfig) => any;

export declare const GitSubmodulesConfigFilterSensitiveLog: (obj: GitSubmodulesConfig) => any;

export declare const ProjectSourceFilterSensitiveLog: (obj: ProjectSource) => any;

export declare const ProjectSourceVersionFilterSensitiveLog: (obj: ProjectSourceVersion) => any;

export declare const VpcConfigFilterSensitiveLog: (obj: VpcConfig) => any;

export declare const BuildBatchFilterSensitiveLog: (obj: BuildBatch) => any;

export declare const BatchGetBuildBatchesOutputFilterSensitiveLog: (obj: BatchGetBuildBatchesOutput) => any;

export declare const BatchGetBuildsInputFilterSensitiveLog: (obj: BatchGetBuildsInput) => any;

export declare const DebugSessionFilterSensitiveLog: (obj: DebugSession) => any;

export declare const ExportedEnvironmentVariableFilterSensitiveLog: (obj: ExportedEnvironmentVariable) => any;

export declare const LogsLocationFilterSensitiveLog: (obj: LogsLocation) => any;

export declare const NetworkInterfaceFilterSensitiveLog: (obj: NetworkInterface) => any;

export declare const BuildPhaseFilterSensitiveLog: (obj: BuildPhase) => any;

export declare const BuildFilterSensitiveLog: (obj: Build) => any;

export declare const BatchGetBuildsOutputFilterSensitiveLog: (obj: BatchGetBuildsOutput) => any;

export declare const BatchGetProjectsInputFilterSensitiveLog: (obj: BatchGetProjectsInput) => any;

export declare const ProjectArtifactsFilterSensitiveLog: (obj: ProjectArtifacts) => any;

export declare const ProjectBadgeFilterSensitiveLog: (obj: ProjectBadge) => any;

export declare const TagFilterSensitiveLog: (obj: Tag) => any;

export declare const WebhookFilterFilterSensitiveLog: (obj: WebhookFilter) => any;

export declare const WebhookFilterSensitiveLog: (obj: Webhook) => any;

export declare const ProjectFilterSensitiveLog: (obj: Project) => any;

export declare const BatchGetProjectsOutputFilterSensitiveLog: (obj: BatchGetProjectsOutput) => any;

export declare const BatchGetReportGroupsInputFilterSensitiveLog: (obj: BatchGetReportGroupsInput) => any;

export declare const S3ReportExportConfigFilterSensitiveLog: (obj: S3ReportExportConfig) => any;

export declare const ReportExportConfigFilterSensitiveLog: (obj: ReportExportConfig) => any;

export declare const ReportGroupFilterSensitiveLog: (obj: ReportGroup) => any;

export declare const BatchGetReportGroupsOutputFilterSensitiveLog: (obj: BatchGetReportGroupsOutput) => any;

export declare const BatchGetReportsInputFilterSensitiveLog: (obj: BatchGetReportsInput) => any;

export declare const CodeCoverageReportSummaryFilterSensitiveLog: (obj: CodeCoverageReportSummary) => any;

export declare const TestReportSummaryFilterSensitiveLog: (obj: TestReportSummary) => any;

export declare const ReportFilterSensitiveLog: (obj: Report) => any;

export declare const BatchGetReportsOutputFilterSensitiveLog: (obj: BatchGetReportsOutput) => any;

export declare const BuildBatchFilterFilterSensitiveLog: (obj: BuildBatchFilter) => any;

export declare const CreateProjectInputFilterSensitiveLog: (obj: CreateProjectInput) => any;

export declare const CreateProjectOutputFilterSensitiveLog: (obj: CreateProjectOutput) => any;

export declare const CreateReportGroupInputFilterSensitiveLog: (obj: CreateReportGroupInput) => any;

export declare const CreateReportGroupOutputFilterSensitiveLog: (obj: CreateReportGroupOutput) => any;

export declare const CreateWebhookInputFilterSensitiveLog: (obj: CreateWebhookInput) => any;

export declare const CreateWebhookOutputFilterSensitiveLog: (obj: CreateWebhookOutput) => any;

export declare const DeleteBuildBatchInputFilterSensitiveLog: (obj: DeleteBuildBatchInput) => any;

export declare const DeleteBuildBatchOutputFilterSensitiveLog: (obj: DeleteBuildBatchOutput) => any;

export declare const DeleteProjectInputFilterSensitiveLog: (obj: DeleteProjectInput) => any;

export declare const DeleteProjectOutputFilterSensitiveLog: (obj: DeleteProjectOutput) => any;

export declare const DeleteReportInputFilterSensitiveLog: (obj: DeleteReportInput) => any;

export declare const DeleteReportOutputFilterSensitiveLog: (obj: DeleteReportOutput) => any;

export declare const DeleteReportGroupInputFilterSensitiveLog: (obj: DeleteReportGroupInput) => any;

export declare const DeleteReportGroupOutputFilterSensitiveLog: (obj: DeleteReportGroupOutput) => any;

export declare const DeleteResourcePolicyInputFilterSensitiveLog: (obj: DeleteResourcePolicyInput) => any;

export declare const DeleteResourcePolicyOutputFilterSensitiveLog: (obj: DeleteResourcePolicyOutput) => any;

export declare const DeleteSourceCredentialsInputFilterSensitiveLog: (obj: DeleteSourceCredentialsInput) => any;

export declare const DeleteSourceCredentialsOutputFilterSensitiveLog: (obj: DeleteSourceCredentialsOutput) => any;

export declare const DeleteWebhookInputFilterSensitiveLog: (obj: DeleteWebhookInput) => any;

export declare const DeleteWebhookOutputFilterSensitiveLog: (obj: DeleteWebhookOutput) => any;

export declare const DescribeCodeCoveragesInputFilterSensitiveLog: (obj: DescribeCodeCoveragesInput) => any;

export declare const CodeCoverageFilterSensitiveLog: (obj: CodeCoverage) => any;

export declare const DescribeCodeCoveragesOutputFilterSensitiveLog: (obj: DescribeCodeCoveragesOutput) => any;

export declare const TestCaseFilterFilterSensitiveLog: (obj: TestCaseFilter) => any;

export declare const DescribeTestCasesInputFilterSensitiveLog: (obj: DescribeTestCasesInput) => any;

export declare const TestCaseFilterSensitiveLog: (obj: TestCase) => any;

export declare const DescribeTestCasesOutputFilterSensitiveLog: (obj: DescribeTestCasesOutput) => any;

export declare const GetReportGroupTrendInputFilterSensitiveLog: (obj: GetReportGroupTrendInput) => any;

export declare const ReportWithRawDataFilterSensitiveLog: (obj: ReportWithRawData) => any;

export declare const ReportGroupTrendStatsFilterSensitiveLog: (obj: ReportGroupTrendStats) => any;

export declare const GetReportGroupTrendOutputFilterSensitiveLog: (obj: GetReportGroupTrendOutput) => any;

export declare const GetResourcePolicyInputFilterSensitiveLog: (obj: GetResourcePolicyInput) => any;

export declare const GetResourcePolicyOutputFilterSensitiveLog: (obj: GetResourcePolicyOutput) => any;

export declare const ImportSourceCredentialsInputFilterSensitiveLog: (obj: ImportSourceCredentialsInput) => any;

export declare const ImportSourceCredentialsOutputFilterSensitiveLog: (obj: ImportSourceCredentialsOutput) => any;

export declare const InvalidateProjectCacheInputFilterSensitiveLog: (obj: InvalidateProjectCacheInput) => any;

export declare const InvalidateProjectCacheOutputFilterSensitiveLog: (obj: InvalidateProjectCacheOutput) => any;

export declare const ListBuildBatchesInputFilterSensitiveLog: (obj: ListBuildBatchesInput) => any;

export declare const ListBuildBatchesOutputFilterSensitiveLog: (obj: ListBuildBatchesOutput) => any;

export declare const ListBuildBatchesForProjectInputFilterSensitiveLog: (obj: ListBuildBatchesForProjectInput) => any;

export declare const ListBuildBatchesForProjectOutputFilterSensitiveLog: (obj: ListBuildBatchesForProjectOutput) => any;

export declare const ListBuildsInputFilterSensitiveLog: (obj: ListBuildsInput) => any;

export declare const ListBuildsOutputFilterSensitiveLog: (obj: ListBuildsOutput) => any;

export declare const ListBuildsForProjectInputFilterSensitiveLog: (obj: ListBuildsForProjectInput) => any;

export declare const ListBuildsForProjectOutputFilterSensitiveLog: (obj: ListBuildsForProjectOutput) => any;

export declare const ListCuratedEnvironmentImagesInputFilterSensitiveLog: (obj: ListCuratedEnvironmentImagesInput) => any;

export declare const EnvironmentImageFilterSensitiveLog: (obj: EnvironmentImage) => any;

export declare const EnvironmentLanguageFilterSensitiveLog: (obj: EnvironmentLanguage) => any;

export declare const EnvironmentPlatformFilterSensitiveLog: (obj: EnvironmentPlatform) => any;

export declare const ListCuratedEnvironmentImagesOutputFilterSensitiveLog: (obj: ListCuratedEnvironmentImagesOutput) => any;

export declare const ListProjectsInputFilterSensitiveLog: (obj: ListProjectsInput) => any;

export declare const ListProjectsOutputFilterSensitiveLog: (obj: ListProjectsOutput) => any;

export declare const ListReportGroupsInputFilterSensitiveLog: (obj: ListReportGroupsInput) => any;

export declare const ListReportGroupsOutputFilterSensitiveLog: (obj: ListReportGroupsOutput) => any;

export declare const ReportFilterFilterSensitiveLog: (obj: ReportFilter) => any;

export declare const ListReportsInputFilterSensitiveLog: (obj: ListReportsInput) => any;

export declare const ListReportsOutputFilterSensitiveLog: (obj: ListReportsOutput) => any;

export declare const ListReportsForReportGroupInputFilterSensitiveLog: (obj: ListReportsForReportGroupInput) => any;

export declare const ListReportsForReportGroupOutputFilterSensitiveLog: (obj: ListReportsForReportGroupOutput) => any;

export declare const ListSharedProjectsInputFilterSensitiveLog: (obj: ListSharedProjectsInput) => any;

export declare const ListSharedProjectsOutputFilterSensitiveLog: (obj: ListSharedProjectsOutput) => any;

export declare const ListSharedReportGroupsInputFilterSensitiveLog: (obj: ListSharedReportGroupsInput) => any;

export declare const ListSharedReportGroupsOutputFilterSensitiveLog: (obj: ListSharedReportGroupsOutput) => any;

export declare const ListSourceCredentialsInputFilterSensitiveLog: (obj: ListSourceCredentialsInput) => any;

export declare const SourceCredentialsInfoFilterSensitiveLog: (obj: SourceCredentialsInfo) => any;

export declare const ListSourceCredentialsOutputFilterSensitiveLog: (obj: ListSourceCredentialsOutput) => any;

export declare const PutResourcePolicyInputFilterSensitiveLog: (obj: PutResourcePolicyInput) => any;

export declare const PutResourcePolicyOutputFilterSensitiveLog: (obj: PutResourcePolicyOutput) => any;

export declare const RetryBuildInputFilterSensitiveLog: (obj: RetryBuildInput) => any;

export declare const RetryBuildOutputFilterSensitiveLog: (obj: RetryBuildOutput) => any;

export declare const RetryBuildBatchInputFilterSensitiveLog: (obj: RetryBuildBatchInput) => any;

export declare const RetryBuildBatchOutputFilterSensitiveLog: (obj: RetryBuildBatchOutput) => any;

export declare const StartBuildInputFilterSensitiveLog: (obj: StartBuildInput) => any;

export declare const StartBuildOutputFilterSensitiveLog: (obj: StartBuildOutput) => any;

export declare const StartBuildBatchInputFilterSensitiveLog: (obj: StartBuildBatchInput) => any;

export declare const StartBuildBatchOutputFilterSensitiveLog: (obj: StartBuildBatchOutput) => any;

export declare const StopBuildInputFilterSensitiveLog: (obj: StopBuildInput) => any;

export declare const StopBuildOutputFilterSensitiveLog: (obj: StopBuildOutput) => any;

export declare const StopBuildBatchInputFilterSensitiveLog: (obj: StopBuildBatchInput) => any;

export declare const StopBuildBatchOutputFilterSensitiveLog: (obj: StopBuildBatchOutput) => any;

export declare const UpdateProjectInputFilterSensitiveLog: (obj: UpdateProjectInput) => any;

export declare const UpdateProjectOutputFilterSensitiveLog: (obj: UpdateProjectOutput) => any;

export declare const UpdateProjectVisibilityInputFilterSensitiveLog: (obj: UpdateProjectVisibilityInput) => any;

export declare const UpdateProjectVisibilityOutputFilterSensitiveLog: (obj: UpdateProjectVisibilityOutput) => any;

export declare const UpdateReportGroupInputFilterSensitiveLog: (obj: UpdateReportGroupInput) => any;

export declare const UpdateReportGroupOutputFilterSensitiveLog: (obj: UpdateReportGroupOutput) => any;

export declare const UpdateWebhookInputFilterSensitiveLog: (obj: UpdateWebhookInput) => any;

export declare const UpdateWebhookOutputFilterSensitiveLog: (obj: UpdateWebhookOutput) => any;
