@aws-sdk/client-codebuild 3.50.0 → 3.51.0

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

@@ -0,0 +1,2278 @@
+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 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 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 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 interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message?: string;
+}
+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;
+}