@aws-sdk/client-codedeploy 3.33.0 → 3.36.1

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

@@ -0,0 +1,3195 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AddTagsToOnPremisesInstancesInput {
+    
+    tags: Tag[] | undefined;
+    
+    instanceNames: string[] | undefined;
+}
+export declare namespace AddTagsToOnPremisesInstancesInput {
+    
+    const filterSensitiveLog: (obj: AddTagsToOnPremisesInstancesInput) => any;
+}
+
+export interface InstanceLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "InstanceLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceLimitExceededException {
+    
+    const filterSensitiveLog: (obj: InstanceLimitExceededException) => any;
+}
+
+export interface InstanceNameRequiredException extends __SmithyException, $MetadataBearer {
+    name: "InstanceNameRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceNameRequiredException {
+    
+    const filterSensitiveLog: (obj: InstanceNameRequiredException) => any;
+}
+
+export interface InstanceNotRegisteredException extends __SmithyException, $MetadataBearer {
+    name: "InstanceNotRegisteredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceNotRegisteredException {
+    
+    const filterSensitiveLog: (obj: InstanceNotRegisteredException) => any;
+}
+
+export interface InvalidInstanceNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInstanceNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidInstanceNameException {
+    
+    const filterSensitiveLog: (obj: InvalidInstanceNameException) => any;
+}
+
+export interface InvalidTagException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTagException {
+    
+    const filterSensitiveLog: (obj: InvalidTagException) => any;
+}
+
+export interface TagLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "TagLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace TagLimitExceededException {
+    
+    const filterSensitiveLog: (obj: TagLimitExceededException) => any;
+}
+
+export interface TagRequiredException extends __SmithyException, $MetadataBearer {
+    name: "TagRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace TagRequiredException {
+    
+    const filterSensitiveLog: (obj: TagRequiredException) => any;
+}
+
+export interface Alarm {
+    
+    name?: string;
+}
+export declare namespace Alarm {
+    
+    const filterSensitiveLog: (obj: Alarm) => any;
+}
+
+export interface AlarmConfiguration {
+    
+    enabled?: boolean;
+    
+    ignorePollAlarmFailure?: boolean;
+    
+    alarms?: Alarm[];
+}
+export declare namespace AlarmConfiguration {
+    
+    const filterSensitiveLog: (obj: AlarmConfiguration) => any;
+}
+
+export interface AlarmsLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "AlarmsLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace AlarmsLimitExceededException {
+    
+    const filterSensitiveLog: (obj: AlarmsLimitExceededException) => any;
+}
+
+export interface ApplicationAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ApplicationAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ApplicationAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ApplicationAlreadyExistsException) => any;
+}
+
+export interface ApplicationDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "ApplicationDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ApplicationDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: ApplicationDoesNotExistException) => any;
+}
+export declare enum ComputePlatform {
+    ECS = "ECS",
+    LAMBDA = "Lambda",
+    SERVER = "Server"
+}
+
+export interface ApplicationInfo {
+    
+    applicationId?: string;
+    
+    applicationName?: string;
+    
+    createTime?: Date;
+    
+    linkedToGitHub?: boolean;
+    
+    gitHubAccountName?: string;
+    
+    computePlatform?: ComputePlatform | string;
+}
+export declare namespace ApplicationInfo {
+    
+    const filterSensitiveLog: (obj: ApplicationInfo) => any;
+}
+
+export interface ApplicationLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ApplicationLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ApplicationLimitExceededException {
+    
+    const filterSensitiveLog: (obj: ApplicationLimitExceededException) => any;
+}
+
+export interface ApplicationNameRequiredException extends __SmithyException, $MetadataBearer {
+    name: "ApplicationNameRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ApplicationNameRequiredException {
+    
+    const filterSensitiveLog: (obj: ApplicationNameRequiredException) => any;
+}
+export declare enum ApplicationRevisionSortBy {
+    FirstUsedTime = "firstUsedTime",
+    LastUsedTime = "lastUsedTime",
+    RegisterTime = "registerTime"
+}
+
+export interface AppSpecContent {
+    
+    content?: string;
+    
+    sha256?: string;
+}
+export declare namespace AppSpecContent {
+    
+    const filterSensitiveLog: (obj: AppSpecContent) => any;
+}
+
+export interface ArnNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "ArnNotSupportedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ArnNotSupportedException {
+    
+    const filterSensitiveLog: (obj: ArnNotSupportedException) => any;
+}
+export declare enum AutoRollbackEvent {
+    DEPLOYMENT_FAILURE = "DEPLOYMENT_FAILURE",
+    DEPLOYMENT_STOP_ON_ALARM = "DEPLOYMENT_STOP_ON_ALARM",
+    DEPLOYMENT_STOP_ON_REQUEST = "DEPLOYMENT_STOP_ON_REQUEST"
+}
+
+export interface AutoRollbackConfiguration {
+    
+    enabled?: boolean;
+    
+    events?: (AutoRollbackEvent | string)[];
+}
+export declare namespace AutoRollbackConfiguration {
+    
+    const filterSensitiveLog: (obj: AutoRollbackConfiguration) => any;
+}
+
+export interface AutoScalingGroup {
+    
+    name?: string;
+    
+    hook?: string;
+}
+export declare namespace AutoScalingGroup {
+    
+    const filterSensitiveLog: (obj: AutoScalingGroup) => any;
+}
+
+export interface GitHubLocation {
+    
+    repository?: string;
+    
+    commitId?: string;
+}
+export declare namespace GitHubLocation {
+    
+    const filterSensitiveLog: (obj: GitHubLocation) => any;
+}
+export declare enum RevisionLocationType {
+    AppSpecContent = "AppSpecContent",
+    GitHub = "GitHub",
+    S3 = "S3",
+    String = "String"
+}
+export declare enum BundleType {
+    JSON = "JSON",
+    Tar = "tar",
+    TarGZip = "tgz",
+    YAML = "YAML",
+    Zip = "zip"
+}
+
+export interface S3Location {
+    
+    bucket?: string;
+    
+    key?: string;
+    
+    bundleType?: BundleType | string;
+    
+    version?: string;
+    
+    eTag?: string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+
+export interface RawString {
+    
+    content?: string;
+    
+    sha256?: string;
+}
+export declare namespace RawString {
+    
+    const filterSensitiveLog: (obj: RawString) => any;
+}
+
+export interface RevisionLocation {
+    
+    revisionType?: RevisionLocationType | string;
+    
+    s3Location?: S3Location;
+    
+    gitHubLocation?: GitHubLocation;
+    
+    string?: RawString;
+    
+    appSpecContent?: AppSpecContent;
+}
+export declare namespace RevisionLocation {
+    
+    const filterSensitiveLog: (obj: RevisionLocation) => any;
+}
+
+export interface BatchGetApplicationRevisionsInput {
+    
+    applicationName: string | undefined;
+    
+    revisions: RevisionLocation[] | undefined;
+}
+export declare namespace BatchGetApplicationRevisionsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetApplicationRevisionsInput) => any;
+}
+
+export interface GenericRevisionInfo {
+    
+    description?: string;
+    
+    deploymentGroups?: string[];
+    
+    firstUsedTime?: Date;
+    
+    lastUsedTime?: Date;
+    
+    registerTime?: Date;
+}
+export declare namespace GenericRevisionInfo {
+    
+    const filterSensitiveLog: (obj: GenericRevisionInfo) => any;
+}
+
+export interface RevisionInfo {
+    
+    revisionLocation?: RevisionLocation;
+    
+    genericRevisionInfo?: GenericRevisionInfo;
+}
+export declare namespace RevisionInfo {
+    
+    const filterSensitiveLog: (obj: RevisionInfo) => any;
+}
+
+export interface BatchGetApplicationRevisionsOutput {
+    
+    applicationName?: string;
+    
+    errorMessage?: string;
+    
+    revisions?: RevisionInfo[];
+}
+export declare namespace BatchGetApplicationRevisionsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetApplicationRevisionsOutput) => any;
+}
+
+export interface BatchLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "BatchLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace BatchLimitExceededException {
+    
+    const filterSensitiveLog: (obj: BatchLimitExceededException) => any;
+}
+
+export interface InvalidApplicationNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidApplicationNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidApplicationNameException {
+    
+    const filterSensitiveLog: (obj: InvalidApplicationNameException) => any;
+}
+
+export interface InvalidRevisionException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRevisionException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidRevisionException {
+    
+    const filterSensitiveLog: (obj: InvalidRevisionException) => any;
+}
+
+export interface RevisionRequiredException extends __SmithyException, $MetadataBearer {
+    name: "RevisionRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RevisionRequiredException {
+    
+    const filterSensitiveLog: (obj: RevisionRequiredException) => any;
+}
+
+export interface BatchGetApplicationsInput {
+    
+    applicationNames: string[] | undefined;
+}
+export declare namespace BatchGetApplicationsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetApplicationsInput) => any;
+}
+
+export interface BatchGetApplicationsOutput {
+    
+    applicationsInfo?: ApplicationInfo[];
+}
+export declare namespace BatchGetApplicationsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetApplicationsOutput) => any;
+}
+
+export interface BatchGetDeploymentGroupsInput {
+    
+    applicationName: string | undefined;
+    
+    deploymentGroupNames: string[] | undefined;
+}
+export declare namespace BatchGetDeploymentGroupsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentGroupsInput) => any;
+}
+export declare enum DeploymentReadyAction {
+    CONTINUE_DEPLOYMENT = "CONTINUE_DEPLOYMENT",
+    STOP_DEPLOYMENT = "STOP_DEPLOYMENT"
+}
+
+export interface DeploymentReadyOption {
+    
+    actionOnTimeout?: DeploymentReadyAction | string;
+    
+    waitTimeInMinutes?: number;
+}
+export declare namespace DeploymentReadyOption {
+    
+    const filterSensitiveLog: (obj: DeploymentReadyOption) => any;
+}
+export declare enum GreenFleetProvisioningAction {
+    COPY_AUTO_SCALING_GROUP = "COPY_AUTO_SCALING_GROUP",
+    DISCOVER_EXISTING = "DISCOVER_EXISTING"
+}
+
+export interface GreenFleetProvisioningOption {
+    
+    action?: GreenFleetProvisioningAction | string;
+}
+export declare namespace GreenFleetProvisioningOption {
+    
+    const filterSensitiveLog: (obj: GreenFleetProvisioningOption) => any;
+}
+export declare enum InstanceAction {
+    KEEP_ALIVE = "KEEP_ALIVE",
+    TERMINATE = "TERMINATE"
+}
+
+export interface BlueInstanceTerminationOption {
+    
+    action?: InstanceAction | string;
+    
+    terminationWaitTimeInMinutes?: number;
+}
+export declare namespace BlueInstanceTerminationOption {
+    
+    const filterSensitiveLog: (obj: BlueInstanceTerminationOption) => any;
+}
+
+export interface BlueGreenDeploymentConfiguration {
+    
+    terminateBlueInstancesOnDeploymentSuccess?: BlueInstanceTerminationOption;
+    
+    deploymentReadyOption?: DeploymentReadyOption;
+    
+    greenFleetProvisioningOption?: GreenFleetProvisioningOption;
+}
+export declare namespace BlueGreenDeploymentConfiguration {
+    
+    const filterSensitiveLog: (obj: BlueGreenDeploymentConfiguration) => any;
+}
+export declare enum DeploymentOption {
+    WITHOUT_TRAFFIC_CONTROL = "WITHOUT_TRAFFIC_CONTROL",
+    WITH_TRAFFIC_CONTROL = "WITH_TRAFFIC_CONTROL"
+}
+export declare enum DeploymentType {
+    BLUE_GREEN = "BLUE_GREEN",
+    IN_PLACE = "IN_PLACE"
+}
+
+export interface DeploymentStyle {
+    
+    deploymentType?: DeploymentType | string;
+    
+    deploymentOption?: DeploymentOption | string;
+}
+export declare namespace DeploymentStyle {
+    
+    const filterSensitiveLog: (obj: DeploymentStyle) => any;
+}
+export declare enum EC2TagFilterType {
+    KEY_AND_VALUE = "KEY_AND_VALUE",
+    KEY_ONLY = "KEY_ONLY",
+    VALUE_ONLY = "VALUE_ONLY"
+}
+
+export interface EC2TagFilter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Type?: EC2TagFilterType | string;
+}
+export declare namespace EC2TagFilter {
+    
+    const filterSensitiveLog: (obj: EC2TagFilter) => any;
+}
+
+export interface EC2TagSet {
+    
+    ec2TagSetList?: EC2TagFilter[][];
+}
+export declare namespace EC2TagSet {
+    
+    const filterSensitiveLog: (obj: EC2TagSet) => any;
+}
+
+export interface ECSService {
+    
+    serviceName?: string;
+    
+    clusterName?: string;
+}
+export declare namespace ECSService {
+    
+    const filterSensitiveLog: (obj: ECSService) => any;
+}
+export declare enum DeploymentStatus {
+    BAKING = "Baking",
+    CREATED = "Created",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    QUEUED = "Queued",
+    READY = "Ready",
+    STOPPED = "Stopped",
+    SUCCEEDED = "Succeeded"
+}
+
+export interface LastDeploymentInfo {
+    
+    deploymentId?: string;
+    
+    status?: DeploymentStatus | string;
+    
+    endTime?: Date;
+    
+    createTime?: Date;
+}
+export declare namespace LastDeploymentInfo {
+    
+    const filterSensitiveLog: (obj: LastDeploymentInfo) => any;
+}
+
+export interface ELBInfo {
+    
+    name?: string;
+}
+export declare namespace ELBInfo {
+    
+    const filterSensitiveLog: (obj: ELBInfo) => any;
+}
+
+export interface TargetGroupInfo {
+    
+    name?: string;
+}
+export declare namespace TargetGroupInfo {
+    
+    const filterSensitiveLog: (obj: TargetGroupInfo) => any;
+}
+
+export interface TrafficRoute {
+    
+    listenerArns?: string[];
+}
+export declare namespace TrafficRoute {
+    
+    const filterSensitiveLog: (obj: TrafficRoute) => any;
+}
+
+export interface TargetGroupPairInfo {
+    
+    targetGroups?: TargetGroupInfo[];
+    
+    prodTrafficRoute?: TrafficRoute;
+    
+    testTrafficRoute?: TrafficRoute;
+}
+export declare namespace TargetGroupPairInfo {
+    
+    const filterSensitiveLog: (obj: TargetGroupPairInfo) => any;
+}
+
+export interface LoadBalancerInfo {
+    
+    elbInfoList?: ELBInfo[];
+    
+    targetGroupInfoList?: TargetGroupInfo[];
+    
+    targetGroupPairInfoList?: TargetGroupPairInfo[];
+}
+export declare namespace LoadBalancerInfo {
+    
+    const filterSensitiveLog: (obj: LoadBalancerInfo) => any;
+}
+export declare enum TagFilterType {
+    KEY_AND_VALUE = "KEY_AND_VALUE",
+    KEY_ONLY = "KEY_ONLY",
+    VALUE_ONLY = "VALUE_ONLY"
+}
+
+export interface TagFilter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Type?: TagFilterType | string;
+}
+export declare namespace TagFilter {
+    
+    const filterSensitiveLog: (obj: TagFilter) => any;
+}
+
+export interface OnPremisesTagSet {
+    
+    onPremisesTagSetList?: TagFilter[][];
+}
+export declare namespace OnPremisesTagSet {
+    
+    const filterSensitiveLog: (obj: OnPremisesTagSet) => any;
+}
+export declare enum OutdatedInstancesStrategy {
+    Ignore = "IGNORE",
+    Update = "UPDATE"
+}
+export declare enum TriggerEventType {
+    DEPLOYMENT_FAILURE = "DeploymentFailure",
+    DEPLOYMENT_READY = "DeploymentReady",
+    DEPLOYMENT_ROLLBACK = "DeploymentRollback",
+    DEPLOYMENT_START = "DeploymentStart",
+    DEPLOYMENT_STOP = "DeploymentStop",
+    DEPLOYMENT_SUCCESS = "DeploymentSuccess",
+    INSTANCE_FAILURE = "InstanceFailure",
+    INSTANCE_READY = "InstanceReady",
+    INSTANCE_START = "InstanceStart",
+    INSTANCE_SUCCESS = "InstanceSuccess"
+}
+
+export interface TriggerConfig {
+    
+    triggerName?: string;
+    
+    triggerTargetArn?: string;
+    
+    triggerEvents?: (TriggerEventType | string)[];
+}
+export declare namespace TriggerConfig {
+    
+    const filterSensitiveLog: (obj: TriggerConfig) => any;
+}
+
+export interface DeploymentGroupInfo {
+    
+    applicationName?: string;
+    
+    deploymentGroupId?: string;
+    
+    deploymentGroupName?: string;
+    
+    deploymentConfigName?: string;
+    
+    ec2TagFilters?: EC2TagFilter[];
+    
+    onPremisesInstanceTagFilters?: TagFilter[];
+    
+    autoScalingGroups?: AutoScalingGroup[];
+    
+    serviceRoleArn?: string;
+    
+    targetRevision?: RevisionLocation;
+    
+    triggerConfigurations?: TriggerConfig[];
+    
+    alarmConfiguration?: AlarmConfiguration;
+    
+    autoRollbackConfiguration?: AutoRollbackConfiguration;
+    
+    deploymentStyle?: DeploymentStyle;
+    
+    outdatedInstancesStrategy?: OutdatedInstancesStrategy | string;
+    
+    blueGreenDeploymentConfiguration?: BlueGreenDeploymentConfiguration;
+    
+    loadBalancerInfo?: LoadBalancerInfo;
+    
+    lastSuccessfulDeployment?: LastDeploymentInfo;
+    
+    lastAttemptedDeployment?: LastDeploymentInfo;
+    
+    ec2TagSet?: EC2TagSet;
+    
+    onPremisesTagSet?: OnPremisesTagSet;
+    
+    computePlatform?: ComputePlatform | string;
+    
+    ecsServices?: ECSService[];
+}
+export declare namespace DeploymentGroupInfo {
+    
+    const filterSensitiveLog: (obj: DeploymentGroupInfo) => any;
+}
+
+export interface BatchGetDeploymentGroupsOutput {
+    
+    deploymentGroupsInfo?: DeploymentGroupInfo[];
+    
+    errorMessage?: string;
+}
+export declare namespace BatchGetDeploymentGroupsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentGroupsOutput) => any;
+}
+
+export interface DeploymentConfigDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentConfigDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentConfigDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigDoesNotExistException) => any;
+}
+
+export interface DeploymentGroupNameRequiredException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentGroupNameRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentGroupNameRequiredException {
+    
+    const filterSensitiveLog: (obj: DeploymentGroupNameRequiredException) => any;
+}
+
+export interface InvalidDeploymentGroupNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentGroupNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentGroupNameException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentGroupNameException) => any;
+}
+
+export interface BatchGetDeploymentInstancesInput {
+    
+    deploymentId: string | undefined;
+    
+    instanceIds: string[] | undefined;
+}
+export declare namespace BatchGetDeploymentInstancesInput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentInstancesInput) => any;
+}
+export declare enum _InstanceType {
+    BLUE = "Blue",
+    GREEN = "Green"
+}
+export declare enum LifecycleErrorCode {
+    SCRIPT_FAILED = "ScriptFailed",
+    SCRIPT_MISSING = "ScriptMissing",
+    SCRIPT_NOT_EXECUTABLE = "ScriptNotExecutable",
+    SCRIPT_TIMED_OUT = "ScriptTimedOut",
+    SUCCESS = "Success",
+    UNKNOWN_ERROR = "UnknownError"
+}
+
+export interface Diagnostics {
+    
+    errorCode?: LifecycleErrorCode | string;
+    
+    scriptName?: string;
+    
+    message?: string;
+    
+    logTail?: string;
+}
+export declare namespace Diagnostics {
+    
+    const filterSensitiveLog: (obj: Diagnostics) => any;
+}
+export declare enum LifecycleEventStatus {
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    PENDING = "Pending",
+    SKIPPED = "Skipped",
+    SUCCEEDED = "Succeeded",
+    UNKNOWN = "Unknown"
+}
+
+export interface LifecycleEvent {
+    
+    lifecycleEventName?: string;
+    
+    diagnostics?: Diagnostics;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    status?: LifecycleEventStatus | string;
+}
+export declare namespace LifecycleEvent {
+    
+    const filterSensitiveLog: (obj: LifecycleEvent) => any;
+}
+export declare enum InstanceStatus {
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    PENDING = "Pending",
+    READY = "Ready",
+    SKIPPED = "Skipped",
+    SUCCEEDED = "Succeeded",
+    UNKNOWN = "Unknown"
+}
+
+export interface InstanceSummary {
+    
+    deploymentId?: string;
+    
+    instanceId?: string;
+    
+    status?: InstanceStatus | string;
+    
+    lastUpdatedAt?: Date;
+    
+    lifecycleEvents?: LifecycleEvent[];
+    
+    instanceType?: _InstanceType | string;
+}
+export declare namespace InstanceSummary {
+    
+    const filterSensitiveLog: (obj: InstanceSummary) => any;
+}
+
+export interface BatchGetDeploymentInstancesOutput {
+    
+    instancesSummary?: InstanceSummary[];
+    
+    errorMessage?: string;
+}
+export declare namespace BatchGetDeploymentInstancesOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentInstancesOutput) => any;
+}
+
+export interface DeploymentDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: DeploymentDoesNotExistException) => any;
+}
+
+export interface DeploymentIdRequiredException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentIdRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentIdRequiredException {
+    
+    const filterSensitiveLog: (obj: DeploymentIdRequiredException) => any;
+}
+
+export interface InstanceIdRequiredException extends __SmithyException, $MetadataBearer {
+    name: "InstanceIdRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceIdRequiredException {
+    
+    const filterSensitiveLog: (obj: InstanceIdRequiredException) => any;
+}
+
+export interface InvalidComputePlatformException extends __SmithyException, $MetadataBearer {
+    name: "InvalidComputePlatformException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidComputePlatformException {
+    
+    const filterSensitiveLog: (obj: InvalidComputePlatformException) => any;
+}
+
+export interface InvalidDeploymentIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentIdException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentIdException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentIdException) => any;
+}
+
+export interface BatchGetDeploymentsInput {
+    
+    deploymentIds: string[] | undefined;
+}
+export declare namespace BatchGetDeploymentsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentsInput) => any;
+}
+export declare enum DeploymentCreator {
+    Autoscaling = "autoscaling",
+    CloudFormation = "CloudFormation",
+    CloudFormationRollback = "CloudFormationRollback",
+    CodeDeploy = "CodeDeploy",
+    CodeDeployAutoUpdate = "CodeDeployAutoUpdate",
+    CodeDeployRollback = "codeDeployRollback",
+    User = "user"
+}
+
+export interface DeploymentOverview {
+    
+    Pending?: number;
+    
+    InProgress?: number;
+    
+    Succeeded?: number;
+    
+    Failed?: number;
+    
+    Skipped?: number;
+    
+    Ready?: number;
+}
+export declare namespace DeploymentOverview {
+    
+    const filterSensitiveLog: (obj: DeploymentOverview) => any;
+}
+export declare enum ErrorCode {
+    AGENT_ISSUE = "AGENT_ISSUE",
+    ALARM_ACTIVE = "ALARM_ACTIVE",
+    APPLICATION_MISSING = "APPLICATION_MISSING",
+    AUTOSCALING_VALIDATION_ERROR = "AUTOSCALING_VALIDATION_ERROR",
+    AUTO_SCALING_CONFIGURATION = "AUTO_SCALING_CONFIGURATION",
+    AUTO_SCALING_IAM_ROLE_PERMISSIONS = "AUTO_SCALING_IAM_ROLE_PERMISSIONS",
+    CLOUDFORMATION_STACK_FAILURE = "CLOUDFORMATION_STACK_FAILURE",
+    CODEDEPLOY_RESOURCE_CANNOT_BE_FOUND = "CODEDEPLOY_RESOURCE_CANNOT_BE_FOUND",
+    CUSTOMER_APPLICATION_UNHEALTHY = "CUSTOMER_APPLICATION_UNHEALTHY",
+    DEPLOYMENT_GROUP_MISSING = "DEPLOYMENT_GROUP_MISSING",
+    ECS_UPDATE_ERROR = "ECS_UPDATE_ERROR",
+    ELASTIC_LOAD_BALANCING_INVALID = "ELASTIC_LOAD_BALANCING_INVALID",
+    ELB_INVALID_INSTANCE = "ELB_INVALID_INSTANCE",
+    HEALTH_CONSTRAINTS = "HEALTH_CONSTRAINTS",
+    HEALTH_CONSTRAINTS_INVALID = "HEALTH_CONSTRAINTS_INVALID",
+    HOOK_EXECUTION_FAILURE = "HOOK_EXECUTION_FAILURE",
+    IAM_ROLE_MISSING = "IAM_ROLE_MISSING",
+    IAM_ROLE_PERMISSIONS = "IAM_ROLE_PERMISSIONS",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    INVALID_ECS_SERVICE = "INVALID_ECS_SERVICE",
+    INVALID_LAMBDA_CONFIGURATION = "INVALID_LAMBDA_CONFIGURATION",
+    INVALID_LAMBDA_FUNCTION = "INVALID_LAMBDA_FUNCTION",
+    INVALID_REVISION = "INVALID_REVISION",
+    MANUAL_STOP = "MANUAL_STOP",
+    MISSING_BLUE_GREEN_DEPLOYMENT_CONFIGURATION = "MISSING_BLUE_GREEN_DEPLOYMENT_CONFIGURATION",
+    MISSING_ELB_INFORMATION = "MISSING_ELB_INFORMATION",
+    MISSING_GITHUB_TOKEN = "MISSING_GITHUB_TOKEN",
+    NO_EC2_SUBSCRIPTION = "NO_EC2_SUBSCRIPTION",
+    NO_INSTANCES = "NO_INSTANCES",
+    OVER_MAX_INSTANCES = "OVER_MAX_INSTANCES",
+    RESOURCE_LIMIT_EXCEEDED = "RESOURCE_LIMIT_EXCEEDED",
+    REVISION_MISSING = "REVISION_MISSING",
+    THROTTLED = "THROTTLED",
+    TIMEOUT = "TIMEOUT"
+}
+
+export interface ErrorInformation {
+    
+    code?: ErrorCode | string;
+    
+    message?: string;
+}
+export declare namespace ErrorInformation {
+    
+    const filterSensitiveLog: (obj: ErrorInformation) => any;
+}
+export declare enum FileExistsBehavior {
+    DISALLOW = "DISALLOW",
+    OVERWRITE = "OVERWRITE",
+    RETAIN = "RETAIN"
+}
+
+export interface RelatedDeployments {
+    
+    autoUpdateOutdatedInstancesRootDeploymentId?: string;
+    
+    autoUpdateOutdatedInstancesDeploymentIds?: string[];
+}
+export declare namespace RelatedDeployments {
+    
+    const filterSensitiveLog: (obj: RelatedDeployments) => any;
+}
+
+export interface RollbackInfo {
+    
+    rollbackDeploymentId?: string;
+    
+    rollbackTriggeringDeploymentId?: string;
+    
+    rollbackMessage?: string;
+}
+export declare namespace RollbackInfo {
+    
+    const filterSensitiveLog: (obj: RollbackInfo) => any;
+}
+
+export interface TargetInstances {
+    
+    tagFilters?: EC2TagFilter[];
+    
+    autoScalingGroups?: string[];
+    
+    ec2TagSet?: EC2TagSet;
+}
+export declare namespace TargetInstances {
+    
+    const filterSensitiveLog: (obj: TargetInstances) => any;
+}
+
+export interface DeploymentInfo {
+    
+    applicationName?: string;
+    
+    deploymentGroupName?: string;
+    
+    deploymentConfigName?: string;
+    
+    deploymentId?: string;
+    
+    previousRevision?: RevisionLocation;
+    
+    revision?: RevisionLocation;
+    
+    status?: DeploymentStatus | string;
+    
+    errorInformation?: ErrorInformation;
+    
+    createTime?: Date;
+    
+    startTime?: Date;
+    
+    completeTime?: Date;
+    
+    deploymentOverview?: DeploymentOverview;
+    
+    description?: string;
+    
+    creator?: DeploymentCreator | string;
+    
+    ignoreApplicationStopFailures?: boolean;
+    
+    autoRollbackConfiguration?: AutoRollbackConfiguration;
+    
+    updateOutdatedInstancesOnly?: boolean;
+    
+    rollbackInfo?: RollbackInfo;
+    
+    deploymentStyle?: DeploymentStyle;
+    
+    targetInstances?: TargetInstances;
+    
+    instanceTerminationWaitTimeStarted?: boolean;
+    
+    blueGreenDeploymentConfiguration?: BlueGreenDeploymentConfiguration;
+    
+    loadBalancerInfo?: LoadBalancerInfo;
+    
+    additionalDeploymentStatusInfo?: string;
+    
+    fileExistsBehavior?: FileExistsBehavior | string;
+    
+    deploymentStatusMessages?: string[];
+    
+    computePlatform?: ComputePlatform | string;
+    
+    externalId?: string;
+    
+    relatedDeployments?: RelatedDeployments;
+}
+export declare namespace DeploymentInfo {
+    
+    const filterSensitiveLog: (obj: DeploymentInfo) => any;
+}
+
+export interface BatchGetDeploymentsOutput {
+    
+    deploymentsInfo?: DeploymentInfo[];
+}
+export declare namespace BatchGetDeploymentsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentsOutput) => any;
+}
+export interface BatchGetDeploymentTargetsInput {
+    
+    deploymentId?: string;
+    
+    targetIds?: string[];
+}
+export declare namespace BatchGetDeploymentTargetsInput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentTargetsInput) => any;
+}
+export declare enum TargetStatus {
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    PENDING = "Pending",
+    READY = "Ready",
+    SKIPPED = "Skipped",
+    SUCCEEDED = "Succeeded",
+    UNKNOWN = "Unknown"
+}
+
+export interface CloudFormationTarget {
+    
+    deploymentId?: string;
+    
+    targetId?: string;
+    
+    lastUpdatedAt?: Date;
+    
+    lifecycleEvents?: LifecycleEvent[];
+    
+    status?: TargetStatus | string;
+    
+    resourceType?: string;
+    
+    targetVersionWeight?: number;
+}
+export declare namespace CloudFormationTarget {
+    
+    const filterSensitiveLog: (obj: CloudFormationTarget) => any;
+}
+export declare enum DeploymentTargetType {
+    CLOUDFORMATION_TARGET = "CloudFormationTarget",
+    ECS_TARGET = "ECSTarget",
+    INSTANCE_TARGET = "InstanceTarget",
+    LAMBDA_TARGET = "LambdaTarget"
+}
+export declare enum TargetLabel {
+    BLUE = "Blue",
+    GREEN = "Green"
+}
+
+export interface ECSTaskSet {
+    
+    identifer?: string;
+    
+    desiredCount?: number;
+    
+    pendingCount?: number;
+    
+    runningCount?: number;
+    
+    status?: string;
+    
+    trafficWeight?: number;
+    
+    targetGroup?: TargetGroupInfo;
+    
+    taskSetLabel?: TargetLabel | string;
+}
+export declare namespace ECSTaskSet {
+    
+    const filterSensitiveLog: (obj: ECSTaskSet) => any;
+}
+
+export interface ECSTarget {
+    
+    deploymentId?: string;
+    
+    targetId?: string;
+    
+    targetArn?: string;
+    
+    lastUpdatedAt?: Date;
+    
+    lifecycleEvents?: LifecycleEvent[];
+    
+    status?: TargetStatus | string;
+    
+    taskSetsInfo?: ECSTaskSet[];
+}
+export declare namespace ECSTarget {
+    
+    const filterSensitiveLog: (obj: ECSTarget) => any;
+}
+
+export interface InstanceTarget {
+    
+    deploymentId?: string;
+    
+    targetId?: string;
+    
+    targetArn?: string;
+    
+    status?: TargetStatus | string;
+    
+    lastUpdatedAt?: Date;
+    
+    lifecycleEvents?: LifecycleEvent[];
+    
+    instanceLabel?: TargetLabel | string;
+}
+export declare namespace InstanceTarget {
+    
+    const filterSensitiveLog: (obj: InstanceTarget) => any;
+}
+
+export interface LambdaFunctionInfo {
+    
+    functionName?: string;
+    
+    functionAlias?: string;
+    
+    currentVersion?: string;
+    
+    targetVersion?: string;
+    
+    targetVersionWeight?: number;
+}
+export declare namespace LambdaFunctionInfo {
+    
+    const filterSensitiveLog: (obj: LambdaFunctionInfo) => any;
+}
+
+export interface LambdaTarget {
+    
+    deploymentId?: string;
+    
+    targetId?: string;
+    
+    targetArn?: string;
+    
+    status?: TargetStatus | string;
+    
+    lastUpdatedAt?: Date;
+    
+    lifecycleEvents?: LifecycleEvent[];
+    
+    lambdaFunctionInfo?: LambdaFunctionInfo;
+}
+export declare namespace LambdaTarget {
+    
+    const filterSensitiveLog: (obj: LambdaTarget) => any;
+}
+
+export interface DeploymentTarget {
+    
+    deploymentTargetType?: DeploymentTargetType | string;
+    
+    instanceTarget?: InstanceTarget;
+    
+    lambdaTarget?: LambdaTarget;
+    
+    ecsTarget?: ECSTarget;
+    
+    cloudFormationTarget?: CloudFormationTarget;
+}
+export declare namespace DeploymentTarget {
+    
+    const filterSensitiveLog: (obj: DeploymentTarget) => any;
+}
+export interface BatchGetDeploymentTargetsOutput {
+    
+    deploymentTargets?: DeploymentTarget[];
+}
+export declare namespace BatchGetDeploymentTargetsOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetDeploymentTargetsOutput) => any;
+}
+
+export interface DeploymentNotStartedException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentNotStartedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentNotStartedException {
+    
+    const filterSensitiveLog: (obj: DeploymentNotStartedException) => any;
+}
+
+export interface DeploymentTargetDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentTargetDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentTargetDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: DeploymentTargetDoesNotExistException) => any;
+}
+
+export interface DeploymentTargetIdRequiredException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentTargetIdRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentTargetIdRequiredException {
+    
+    const filterSensitiveLog: (obj: DeploymentTargetIdRequiredException) => any;
+}
+
+export interface DeploymentTargetListSizeExceededException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentTargetListSizeExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentTargetListSizeExceededException {
+    
+    const filterSensitiveLog: (obj: DeploymentTargetListSizeExceededException) => any;
+}
+
+export interface InstanceDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "InstanceDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: InstanceDoesNotExistException) => any;
+}
+
+export interface InvalidDeploymentTargetIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentTargetIdException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentTargetIdException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentTargetIdException) => any;
+}
+
+export interface BatchGetOnPremisesInstancesInput {
+    
+    instanceNames: string[] | undefined;
+}
+export declare namespace BatchGetOnPremisesInstancesInput {
+    
+    const filterSensitiveLog: (obj: BatchGetOnPremisesInstancesInput) => any;
+}
+
+export interface InstanceInfo {
+    
+    instanceName?: string;
+    
+    iamSessionArn?: string;
+    
+    iamUserArn?: string;
+    
+    instanceArn?: string;
+    
+    registerTime?: Date;
+    
+    deregisterTime?: Date;
+    
+    tags?: Tag[];
+}
+export declare namespace InstanceInfo {
+    
+    const filterSensitiveLog: (obj: InstanceInfo) => any;
+}
+
+export interface BatchGetOnPremisesInstancesOutput {
+    
+    instanceInfos?: InstanceInfo[];
+}
+export declare namespace BatchGetOnPremisesInstancesOutput {
+    
+    const filterSensitiveLog: (obj: BatchGetOnPremisesInstancesOutput) => any;
+}
+
+export interface BucketNameFilterRequiredException extends __SmithyException, $MetadataBearer {
+    name: "BucketNameFilterRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace BucketNameFilterRequiredException {
+    
+    const filterSensitiveLog: (obj: BucketNameFilterRequiredException) => any;
+}
+export declare enum DeploymentWaitType {
+    READY_WAIT = "READY_WAIT",
+    TERMINATION_WAIT = "TERMINATION_WAIT"
+}
+export interface ContinueDeploymentInput {
+    
+    deploymentId?: string;
+    
+    deploymentWaitType?: DeploymentWaitType | string;
+}
+export declare namespace ContinueDeploymentInput {
+    
+    const filterSensitiveLog: (obj: ContinueDeploymentInput) => any;
+}
+
+export interface DeploymentAlreadyCompletedException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentAlreadyCompletedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentAlreadyCompletedException {
+    
+    const filterSensitiveLog: (obj: DeploymentAlreadyCompletedException) => any;
+}
+
+export interface DeploymentIsNotInReadyStateException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentIsNotInReadyStateException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentIsNotInReadyStateException {
+    
+    const filterSensitiveLog: (obj: DeploymentIsNotInReadyStateException) => any;
+}
+
+export interface InvalidDeploymentStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentStatusException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentStatusException) => any;
+}
+
+export interface InvalidDeploymentWaitTypeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentWaitTypeException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentWaitTypeException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentWaitTypeException) => any;
+}
+
+export interface UnsupportedActionForDeploymentTypeException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedActionForDeploymentTypeException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace UnsupportedActionForDeploymentTypeException {
+    
+    const filterSensitiveLog: (obj: UnsupportedActionForDeploymentTypeException) => any;
+}
+
+export interface CreateApplicationInput {
+    
+    applicationName: string | undefined;
+    
+    computePlatform?: ComputePlatform | string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateApplicationInput {
+    
+    const filterSensitiveLog: (obj: CreateApplicationInput) => any;
+}
+
+export interface CreateApplicationOutput {
+    
+    applicationId?: string;
+}
+export declare namespace CreateApplicationOutput {
+    
+    const filterSensitiveLog: (obj: CreateApplicationOutput) => any;
+}
+
+export interface InvalidTagsToAddException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagsToAddException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTagsToAddException {
+    
+    const filterSensitiveLog: (obj: InvalidTagsToAddException) => any;
+}
+
+export interface CreateDeploymentInput {
+    
+    applicationName: string | undefined;
+    
+    deploymentGroupName?: string;
+    
+    revision?: RevisionLocation;
+    
+    deploymentConfigName?: string;
+    
+    description?: string;
+    
+    ignoreApplicationStopFailures?: boolean;
+    
+    targetInstances?: TargetInstances;
+    
+    autoRollbackConfiguration?: AutoRollbackConfiguration;
+    
+    updateOutdatedInstancesOnly?: boolean;
+    
+    fileExistsBehavior?: FileExistsBehavior | string;
+}
+export declare namespace CreateDeploymentInput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentInput) => any;
+}
+
+export interface CreateDeploymentOutput {
+    
+    deploymentId?: string;
+}
+export declare namespace CreateDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentOutput) => any;
+}
+
+export interface DeploymentGroupDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentGroupDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentGroupDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: DeploymentGroupDoesNotExistException) => any;
+}
+
+export interface DeploymentLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentLimitExceededException {
+    
+    const filterSensitiveLog: (obj: DeploymentLimitExceededException) => any;
+}
+
+export interface DescriptionTooLongException extends __SmithyException, $MetadataBearer {
+    name: "DescriptionTooLongException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DescriptionTooLongException {
+    
+    const filterSensitiveLog: (obj: DescriptionTooLongException) => any;
+}
+
+export interface InvalidAutoRollbackConfigException extends __SmithyException, $MetadataBearer {
+    name: "InvalidAutoRollbackConfigException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidAutoRollbackConfigException {
+    
+    const filterSensitiveLog: (obj: InvalidAutoRollbackConfigException) => any;
+}
+
+export interface InvalidAutoScalingGroupException extends __SmithyException, $MetadataBearer {
+    name: "InvalidAutoScalingGroupException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidAutoScalingGroupException {
+    
+    const filterSensitiveLog: (obj: InvalidAutoScalingGroupException) => any;
+}
+
+export interface InvalidDeploymentConfigNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentConfigNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentConfigNameException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentConfigNameException) => any;
+}
+
+export interface InvalidFileExistsBehaviorException extends __SmithyException, $MetadataBearer {
+    name: "InvalidFileExistsBehaviorException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidFileExistsBehaviorException {
+    
+    const filterSensitiveLog: (obj: InvalidFileExistsBehaviorException) => any;
+}
+
+export interface InvalidGitHubAccountTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidGitHubAccountTokenException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidGitHubAccountTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidGitHubAccountTokenException) => any;
+}
+
+export interface InvalidIgnoreApplicationStopFailuresValueException extends __SmithyException, $MetadataBearer {
+    name: "InvalidIgnoreApplicationStopFailuresValueException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidIgnoreApplicationStopFailuresValueException {
+    
+    const filterSensitiveLog: (obj: InvalidIgnoreApplicationStopFailuresValueException) => any;
+}
+
+export interface InvalidLoadBalancerInfoException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLoadBalancerInfoException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidLoadBalancerInfoException {
+    
+    const filterSensitiveLog: (obj: InvalidLoadBalancerInfoException) => any;
+}
+
+export interface InvalidRoleException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRoleException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidRoleException {
+    
+    const filterSensitiveLog: (obj: InvalidRoleException) => any;
+}
+
+export interface InvalidTargetInstancesException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTargetInstancesException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTargetInstancesException {
+    
+    const filterSensitiveLog: (obj: InvalidTargetInstancesException) => any;
+}
+
+export interface InvalidTrafficRoutingConfigurationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTrafficRoutingConfigurationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTrafficRoutingConfigurationException {
+    
+    const filterSensitiveLog: (obj: InvalidTrafficRoutingConfigurationException) => any;
+}
+
+export interface InvalidUpdateOutdatedInstancesOnlyValueException extends __SmithyException, $MetadataBearer {
+    name: "InvalidUpdateOutdatedInstancesOnlyValueException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidUpdateOutdatedInstancesOnlyValueException {
+    
+    const filterSensitiveLog: (obj: InvalidUpdateOutdatedInstancesOnlyValueException) => any;
+}
+
+export interface RevisionDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "RevisionDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RevisionDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: RevisionDoesNotExistException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+export declare type MinimumHealthyHostsType = "FLEET_PERCENT" | "HOST_COUNT";
+
+export interface MinimumHealthyHosts {
+    
+    type?: MinimumHealthyHostsType | string;
+    
+    value?: number;
+}
+export declare namespace MinimumHealthyHosts {
+    
+    const filterSensitiveLog: (obj: MinimumHealthyHosts) => any;
+}
+
+export interface TimeBasedCanary {
+    
+    canaryPercentage?: number;
+    
+    canaryInterval?: number;
+}
+export declare namespace TimeBasedCanary {
+    
+    const filterSensitiveLog: (obj: TimeBasedCanary) => any;
+}
+
+export interface TimeBasedLinear {
+    
+    linearPercentage?: number;
+    
+    linearInterval?: number;
+}
+export declare namespace TimeBasedLinear {
+    
+    const filterSensitiveLog: (obj: TimeBasedLinear) => any;
+}
+export declare enum TrafficRoutingType {
+    AllAtOnce = "AllAtOnce",
+    TimeBasedCanary = "TimeBasedCanary",
+    TimeBasedLinear = "TimeBasedLinear"
+}
+
+export interface TrafficRoutingConfig {
+    
+    type?: TrafficRoutingType | string;
+    
+    timeBasedCanary?: TimeBasedCanary;
+    
+    timeBasedLinear?: TimeBasedLinear;
+}
+export declare namespace TrafficRoutingConfig {
+    
+    const filterSensitiveLog: (obj: TrafficRoutingConfig) => any;
+}
+
+export interface CreateDeploymentConfigInput {
+    
+    deploymentConfigName: string | undefined;
+    
+    minimumHealthyHosts?: MinimumHealthyHosts;
+    
+    trafficRoutingConfig?: TrafficRoutingConfig;
+    
+    computePlatform?: ComputePlatform | string;
+}
+export declare namespace CreateDeploymentConfigInput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentConfigInput) => any;
+}
+
+export interface CreateDeploymentConfigOutput {
+    
+    deploymentConfigId?: string;
+}
+export declare namespace CreateDeploymentConfigOutput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentConfigOutput) => any;
+}
+
+export interface DeploymentConfigAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentConfigAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentConfigAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigAlreadyExistsException) => any;
+}
+
+export interface DeploymentConfigLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentConfigLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentConfigLimitExceededException {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigLimitExceededException) => any;
+}
+
+export interface DeploymentConfigNameRequiredException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentConfigNameRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentConfigNameRequiredException {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigNameRequiredException) => any;
+}
+
+export interface InvalidMinimumHealthyHostValueException extends __SmithyException, $MetadataBearer {
+    name: "InvalidMinimumHealthyHostValueException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidMinimumHealthyHostValueException {
+    
+    const filterSensitiveLog: (obj: InvalidMinimumHealthyHostValueException) => any;
+}
+
+export interface CreateDeploymentGroupInput {
+    
+    applicationName: string | undefined;
+    
+    deploymentGroupName: string | undefined;
+    
+    deploymentConfigName?: string;
+    
+    ec2TagFilters?: EC2TagFilter[];
+    
+    onPremisesInstanceTagFilters?: TagFilter[];
+    
+    autoScalingGroups?: string[];
+    
+    serviceRoleArn: string | undefined;
+    
+    triggerConfigurations?: TriggerConfig[];
+    
+    alarmConfiguration?: AlarmConfiguration;
+    
+    autoRollbackConfiguration?: AutoRollbackConfiguration;
+    
+    outdatedInstancesStrategy?: OutdatedInstancesStrategy | string;
+    
+    deploymentStyle?: DeploymentStyle;
+    
+    blueGreenDeploymentConfiguration?: BlueGreenDeploymentConfiguration;
+    
+    loadBalancerInfo?: LoadBalancerInfo;
+    
+    ec2TagSet?: EC2TagSet;
+    
+    ecsServices?: ECSService[];
+    
+    onPremisesTagSet?: OnPremisesTagSet;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateDeploymentGroupInput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentGroupInput) => any;
+}
+
+export interface CreateDeploymentGroupOutput {
+    
+    deploymentGroupId?: string;
+}
+export declare namespace CreateDeploymentGroupOutput {
+    
+    const filterSensitiveLog: (obj: CreateDeploymentGroupOutput) => any;
+}
+
+export interface DeploymentGroupAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentGroupAlreadyExistsException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentGroupAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: DeploymentGroupAlreadyExistsException) => any;
+}
+
+export interface DeploymentGroupLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentGroupLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentGroupLimitExceededException {
+    
+    const filterSensitiveLog: (obj: DeploymentGroupLimitExceededException) => any;
+}
+
+export interface ECSServiceMappingLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ECSServiceMappingLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ECSServiceMappingLimitExceededException {
+    
+    const filterSensitiveLog: (obj: ECSServiceMappingLimitExceededException) => any;
+}
+
+export interface InvalidAlarmConfigException extends __SmithyException, $MetadataBearer {
+    name: "InvalidAlarmConfigException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidAlarmConfigException {
+    
+    const filterSensitiveLog: (obj: InvalidAlarmConfigException) => any;
+}
+
+export interface InvalidBlueGreenDeploymentConfigurationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidBlueGreenDeploymentConfigurationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidBlueGreenDeploymentConfigurationException {
+    
+    const filterSensitiveLog: (obj: InvalidBlueGreenDeploymentConfigurationException) => any;
+}
+
+export interface InvalidDeploymentStyleException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentStyleException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentStyleException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentStyleException) => any;
+}
+
+export interface InvalidEC2TagCombinationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEC2TagCombinationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidEC2TagCombinationException {
+    
+    const filterSensitiveLog: (obj: InvalidEC2TagCombinationException) => any;
+}
+
+export interface InvalidEC2TagException extends __SmithyException, $MetadataBearer {
+    name: "InvalidEC2TagException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidEC2TagException {
+    
+    const filterSensitiveLog: (obj: InvalidEC2TagException) => any;
+}
+
+export interface InvalidECSServiceException extends __SmithyException, $MetadataBearer {
+    name: "InvalidECSServiceException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidECSServiceException {
+    
+    const filterSensitiveLog: (obj: InvalidECSServiceException) => any;
+}
+
+export interface InvalidInputException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInputException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidInputException {
+    
+    const filterSensitiveLog: (obj: InvalidInputException) => any;
+}
+
+export interface InvalidOnPremisesTagCombinationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidOnPremisesTagCombinationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidOnPremisesTagCombinationException {
+    
+    const filterSensitiveLog: (obj: InvalidOnPremisesTagCombinationException) => any;
+}
+
+export interface InvalidTargetGroupPairException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTargetGroupPairException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTargetGroupPairException {
+    
+    const filterSensitiveLog: (obj: InvalidTargetGroupPairException) => any;
+}
+
+export interface InvalidTriggerConfigException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTriggerConfigException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTriggerConfigException {
+    
+    const filterSensitiveLog: (obj: InvalidTriggerConfigException) => any;
+}
+
+export interface LifecycleHookLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LifecycleHookLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LifecycleHookLimitExceededException {
+    
+    const filterSensitiveLog: (obj: LifecycleHookLimitExceededException) => any;
+}
+
+export interface RoleRequiredException extends __SmithyException, $MetadataBearer {
+    name: "RoleRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace RoleRequiredException {
+    
+    const filterSensitiveLog: (obj: RoleRequiredException) => any;
+}
+
+export interface TagSetListLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "TagSetListLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace TagSetListLimitExceededException {
+    
+    const filterSensitiveLog: (obj: TagSetListLimitExceededException) => any;
+}
+
+export interface TriggerTargetsLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "TriggerTargetsLimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace TriggerTargetsLimitExceededException {
+    
+    const filterSensitiveLog: (obj: TriggerTargetsLimitExceededException) => any;
+}
+
+export interface DeleteApplicationInput {
+    
+    applicationName: string | undefined;
+}
+export declare namespace DeleteApplicationInput {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationInput) => any;
+}
+
+export interface DeleteDeploymentConfigInput {
+    
+    deploymentConfigName: string | undefined;
+}
+export declare namespace DeleteDeploymentConfigInput {
+    
+    const filterSensitiveLog: (obj: DeleteDeploymentConfigInput) => any;
+}
+
+export interface DeploymentConfigInUseException extends __SmithyException, $MetadataBearer {
+    name: "DeploymentConfigInUseException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace DeploymentConfigInUseException {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigInUseException) => any;
+}
+
+export interface InvalidOperationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidOperationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidOperationException {
+    
+    const filterSensitiveLog: (obj: InvalidOperationException) => any;
+}
+
+export interface DeleteDeploymentGroupInput {
+    
+    applicationName: string | undefined;
+    
+    deploymentGroupName: string | undefined;
+}
+export declare namespace DeleteDeploymentGroupInput {
+    
+    const filterSensitiveLog: (obj: DeleteDeploymentGroupInput) => any;
+}
+
+export interface DeleteDeploymentGroupOutput {
+    
+    hooksNotCleanedUp?: AutoScalingGroup[];
+}
+export declare namespace DeleteDeploymentGroupOutput {
+    
+    const filterSensitiveLog: (obj: DeleteDeploymentGroupOutput) => any;
+}
+
+export interface DeleteGitHubAccountTokenInput {
+    
+    tokenName?: string;
+}
+export declare namespace DeleteGitHubAccountTokenInput {
+    
+    const filterSensitiveLog: (obj: DeleteGitHubAccountTokenInput) => any;
+}
+
+export interface DeleteGitHubAccountTokenOutput {
+    
+    tokenName?: string;
+}
+export declare namespace DeleteGitHubAccountTokenOutput {
+    
+    const filterSensitiveLog: (obj: DeleteGitHubAccountTokenOutput) => any;
+}
+
+export interface GitHubAccountTokenDoesNotExistException extends __SmithyException, $MetadataBearer {
+    name: "GitHubAccountTokenDoesNotExistException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace GitHubAccountTokenDoesNotExistException {
+    
+    const filterSensitiveLog: (obj: GitHubAccountTokenDoesNotExistException) => any;
+}
+
+export interface GitHubAccountTokenNameRequiredException extends __SmithyException, $MetadataBearer {
+    name: "GitHubAccountTokenNameRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace GitHubAccountTokenNameRequiredException {
+    
+    const filterSensitiveLog: (obj: GitHubAccountTokenNameRequiredException) => any;
+}
+
+export interface InvalidGitHubAccountTokenNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidGitHubAccountTokenNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidGitHubAccountTokenNameException {
+    
+    const filterSensitiveLog: (obj: InvalidGitHubAccountTokenNameException) => any;
+}
+
+export interface OperationNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotSupportedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace OperationNotSupportedException {
+    
+    const filterSensitiveLog: (obj: OperationNotSupportedException) => any;
+}
+
+export interface ResourceValidationException extends __SmithyException, $MetadataBearer {
+    name: "ResourceValidationException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ResourceValidationException {
+    
+    const filterSensitiveLog: (obj: ResourceValidationException) => any;
+}
+export interface DeleteResourcesByExternalIdInput {
+    
+    externalId?: string;
+}
+export declare namespace DeleteResourcesByExternalIdInput {
+    
+    const filterSensitiveLog: (obj: DeleteResourcesByExternalIdInput) => any;
+}
+export interface DeleteResourcesByExternalIdOutput {
+}
+export declare namespace DeleteResourcesByExternalIdOutput {
+    
+    const filterSensitiveLog: (obj: DeleteResourcesByExternalIdOutput) => any;
+}
+
+export interface DeregisterOnPremisesInstanceInput {
+    
+    instanceName: string | undefined;
+}
+export declare namespace DeregisterOnPremisesInstanceInput {
+    
+    const filterSensitiveLog: (obj: DeregisterOnPremisesInstanceInput) => any;
+}
+
+export interface GetApplicationInput {
+    
+    applicationName: string | undefined;
+}
+export declare namespace GetApplicationInput {
+    
+    const filterSensitiveLog: (obj: GetApplicationInput) => any;
+}
+
+export interface GetApplicationOutput {
+    
+    application?: ApplicationInfo;
+}
+export declare namespace GetApplicationOutput {
+    
+    const filterSensitiveLog: (obj: GetApplicationOutput) => any;
+}
+
+export interface GetApplicationRevisionInput {
+    
+    applicationName: string | undefined;
+    
+    revision: RevisionLocation | undefined;
+}
+export declare namespace GetApplicationRevisionInput {
+    
+    const filterSensitiveLog: (obj: GetApplicationRevisionInput) => any;
+}
+
+export interface GetApplicationRevisionOutput {
+    
+    applicationName?: string;
+    
+    revision?: RevisionLocation;
+    
+    revisionInfo?: GenericRevisionInfo;
+}
+export declare namespace GetApplicationRevisionOutput {
+    
+    const filterSensitiveLog: (obj: GetApplicationRevisionOutput) => any;
+}
+
+export interface GetDeploymentInput {
+    
+    deploymentId: string | undefined;
+}
+export declare namespace GetDeploymentInput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentInput) => any;
+}
+
+export interface GetDeploymentOutput {
+    
+    deploymentInfo?: DeploymentInfo;
+}
+export declare namespace GetDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentOutput) => any;
+}
+
+export interface GetDeploymentConfigInput {
+    
+    deploymentConfigName: string | undefined;
+}
+export declare namespace GetDeploymentConfigInput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentConfigInput) => any;
+}
+
+export interface DeploymentConfigInfo {
+    
+    deploymentConfigId?: string;
+    
+    deploymentConfigName?: string;
+    
+    minimumHealthyHosts?: MinimumHealthyHosts;
+    
+    createTime?: Date;
+    
+    computePlatform?: ComputePlatform | string;
+    
+    trafficRoutingConfig?: TrafficRoutingConfig;
+}
+export declare namespace DeploymentConfigInfo {
+    
+    const filterSensitiveLog: (obj: DeploymentConfigInfo) => any;
+}
+
+export interface GetDeploymentConfigOutput {
+    
+    deploymentConfigInfo?: DeploymentConfigInfo;
+}
+export declare namespace GetDeploymentConfigOutput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentConfigOutput) => any;
+}
+
+export interface GetDeploymentGroupInput {
+    
+    applicationName: string | undefined;
+    
+    deploymentGroupName: string | undefined;
+}
+export declare namespace GetDeploymentGroupInput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentGroupInput) => any;
+}
+
+export interface GetDeploymentGroupOutput {
+    
+    deploymentGroupInfo?: DeploymentGroupInfo;
+}
+export declare namespace GetDeploymentGroupOutput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentGroupOutput) => any;
+}
+
+export interface GetDeploymentInstanceInput {
+    
+    deploymentId: string | undefined;
+    
+    instanceId: string | undefined;
+}
+export declare namespace GetDeploymentInstanceInput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentInstanceInput) => any;
+}
+
+export interface GetDeploymentInstanceOutput {
+    
+    instanceSummary?: InstanceSummary;
+}
+export declare namespace GetDeploymentInstanceOutput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentInstanceOutput) => any;
+}
+export interface GetDeploymentTargetInput {
+    
+    deploymentId?: string;
+    
+    targetId?: string;
+}
+export declare namespace GetDeploymentTargetInput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentTargetInput) => any;
+}
+export interface GetDeploymentTargetOutput {
+    
+    deploymentTarget?: DeploymentTarget;
+}
+export declare namespace GetDeploymentTargetOutput {
+    
+    const filterSensitiveLog: (obj: GetDeploymentTargetOutput) => any;
+}
+
+export interface GetOnPremisesInstanceInput {
+    
+    instanceName: string | undefined;
+}
+export declare namespace GetOnPremisesInstanceInput {
+    
+    const filterSensitiveLog: (obj: GetOnPremisesInstanceInput) => any;
+}
+
+export interface GetOnPremisesInstanceOutput {
+    
+    instanceInfo?: InstanceInfo;
+}
+export declare namespace GetOnPremisesInstanceOutput {
+    
+    const filterSensitiveLog: (obj: GetOnPremisesInstanceOutput) => any;
+}
+
+export interface InvalidBucketNameFilterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidBucketNameFilterException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidBucketNameFilterException {
+    
+    const filterSensitiveLog: (obj: InvalidBucketNameFilterException) => any;
+}
+
+export interface InvalidDeployedStateFilterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeployedStateFilterException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeployedStateFilterException {
+    
+    const filterSensitiveLog: (obj: InvalidDeployedStateFilterException) => any;
+}
+
+export interface InvalidKeyPrefixFilterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidKeyPrefixFilterException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidKeyPrefixFilterException {
+    
+    const filterSensitiveLog: (obj: InvalidKeyPrefixFilterException) => any;
+}
+
+export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextTokenException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidNextTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
+}
+
+export interface InvalidSortByException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSortByException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidSortByException {
+    
+    const filterSensitiveLog: (obj: InvalidSortByException) => any;
+}
+
+export interface InvalidSortOrderException extends __SmithyException, $MetadataBearer {
+    name: "InvalidSortOrderException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidSortOrderException {
+    
+    const filterSensitiveLog: (obj: InvalidSortOrderException) => any;
+}
+export declare enum ListStateFilterAction {
+    Exclude = "exclude",
+    Ignore = "ignore",
+    Include = "include"
+}
+export declare enum SortOrder {
+    Ascending = "ascending",
+    Descending = "descending"
+}
+
+export interface ListApplicationRevisionsInput {
+    
+    applicationName: string | undefined;
+    
+    sortBy?: ApplicationRevisionSortBy | string;
+    
+    sortOrder?: SortOrder | string;
+    
+    s3Bucket?: string;
+    
+    s3KeyPrefix?: string;
+    
+    deployed?: ListStateFilterAction | string;
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationRevisionsInput {
+    
+    const filterSensitiveLog: (obj: ListApplicationRevisionsInput) => any;
+}
+
+export interface ListApplicationRevisionsOutput {
+    
+    revisions?: RevisionLocation[];
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationRevisionsOutput {
+    
+    const filterSensitiveLog: (obj: ListApplicationRevisionsOutput) => any;
+}
+
+export interface ListApplicationsInput {
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationsInput {
+    
+    const filterSensitiveLog: (obj: ListApplicationsInput) => any;
+}
+
+export interface ListApplicationsOutput {
+    
+    applications?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListApplicationsOutput {
+    
+    const filterSensitiveLog: (obj: ListApplicationsOutput) => any;
+}
+
+export interface ListDeploymentConfigsInput {
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentConfigsInput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentConfigsInput) => any;
+}
+
+export interface ListDeploymentConfigsOutput {
+    
+    deploymentConfigsList?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentConfigsOutput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentConfigsOutput) => any;
+}
+
+export interface ListDeploymentGroupsInput {
+    
+    applicationName: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentGroupsInput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentGroupsInput) => any;
+}
+
+export interface ListDeploymentGroupsOutput {
+    
+    applicationName?: string;
+    
+    deploymentGroups?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentGroupsOutput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentGroupsOutput) => any;
+}
+
+export interface InvalidDeploymentInstanceTypeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidDeploymentInstanceTypeException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidDeploymentInstanceTypeException {
+    
+    const filterSensitiveLog: (obj: InvalidDeploymentInstanceTypeException) => any;
+}
+
+export interface InvalidInstanceStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInstanceStatusException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidInstanceStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidInstanceStatusException) => any;
+}
+
+export interface InvalidInstanceTypeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidInstanceTypeException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidInstanceTypeException {
+    
+    const filterSensitiveLog: (obj: InvalidInstanceTypeException) => any;
+}
+
+export interface InvalidTargetFilterNameException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTargetFilterNameException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTargetFilterNameException {
+    
+    const filterSensitiveLog: (obj: InvalidTargetFilterNameException) => any;
+}
+
+export interface ListDeploymentInstancesInput {
+    
+    deploymentId: string | undefined;
+    
+    nextToken?: string;
+    
+    instanceStatusFilter?: (InstanceStatus | string)[];
+    
+    instanceTypeFilter?: (_InstanceType | string)[];
+}
+export declare namespace ListDeploymentInstancesInput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentInstancesInput) => any;
+}
+
+export interface ListDeploymentInstancesOutput {
+    
+    instancesList?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentInstancesOutput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentInstancesOutput) => any;
+}
+
+export interface InvalidExternalIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidExternalIdException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidExternalIdException {
+    
+    const filterSensitiveLog: (obj: InvalidExternalIdException) => any;
+}
+
+export interface InvalidTimeRangeException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTimeRangeException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTimeRangeException {
+    
+    const filterSensitiveLog: (obj: InvalidTimeRangeException) => any;
+}
+
+export interface TimeRange {
+    
+    start?: Date;
+    
+    end?: Date;
+}
+export declare namespace TimeRange {
+    
+    const filterSensitiveLog: (obj: TimeRange) => any;
+}
+
+export interface ListDeploymentsInput {
+    
+    applicationName?: string;
+    
+    deploymentGroupName?: string;
+    
+    externalId?: string;
+    
+    includeOnlyStatuses?: (DeploymentStatus | string)[];
+    
+    createTimeRange?: TimeRange;
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentsInput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsInput) => any;
+}
+
+export interface ListDeploymentsOutput {
+    
+    deployments?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentsOutput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentsOutput) => any;
+}
+export declare enum TargetFilterName {
+    SERVER_INSTANCE_LABEL = "ServerInstanceLabel",
+    TARGET_STATUS = "TargetStatus"
+}
+export interface ListDeploymentTargetsInput {
+    
+    deploymentId?: string;
+    
+    nextToken?: string;
+    
+    targetFilters?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace ListDeploymentTargetsInput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentTargetsInput) => any;
+}
+export interface ListDeploymentTargetsOutput {
+    
+    targetIds?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeploymentTargetsOutput {
+    
+    const filterSensitiveLog: (obj: ListDeploymentTargetsOutput) => any;
+}
+
+export interface ListGitHubAccountTokenNamesInput {
+    
+    nextToken?: string;
+}
+export declare namespace ListGitHubAccountTokenNamesInput {
+    
+    const filterSensitiveLog: (obj: ListGitHubAccountTokenNamesInput) => any;
+}
+
+export interface ListGitHubAccountTokenNamesOutput {
+    
+    tokenNameList?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListGitHubAccountTokenNamesOutput {
+    
+    const filterSensitiveLog: (obj: ListGitHubAccountTokenNamesOutput) => any;
+}
+
+export interface InvalidRegistrationStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRegistrationStatusException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidRegistrationStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidRegistrationStatusException) => any;
+}
+
+export interface InvalidTagFilterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidTagFilterException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidTagFilterException {
+    
+    const filterSensitiveLog: (obj: InvalidTagFilterException) => any;
+}
+export declare enum RegistrationStatus {
+    Deregistered = "Deregistered",
+    Registered = "Registered"
+}
+
+export interface ListOnPremisesInstancesInput {
+    
+    registrationStatus?: RegistrationStatus | string;
+    
+    tagFilters?: TagFilter[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOnPremisesInstancesInput {
+    
+    const filterSensitiveLog: (obj: ListOnPremisesInstancesInput) => any;
+}
+
+export interface ListOnPremisesInstancesOutput {
+    
+    instanceNames?: string[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOnPremisesInstancesOutput {
+    
+    const filterSensitiveLog: (obj: ListOnPremisesInstancesOutput) => any;
+}
+
+export interface InvalidArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidArnException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidArnException {
+    
+    const filterSensitiveLog: (obj: InvalidArnException) => any;
+}
+export interface ListTagsForResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+export interface ListTagsForResourceOutput {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+
+export interface ResourceArnRequiredException extends __SmithyException, $MetadataBearer {
+    name: "ResourceArnRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ResourceArnRequiredException {
+    
+    const filterSensitiveLog: (obj: ResourceArnRequiredException) => any;
+}
+
+export interface InvalidLifecycleEventHookExecutionIdException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLifecycleEventHookExecutionIdException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidLifecycleEventHookExecutionIdException {
+    
+    const filterSensitiveLog: (obj: InvalidLifecycleEventHookExecutionIdException) => any;
+}
+
+export interface InvalidLifecycleEventHookExecutionStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidLifecycleEventHookExecutionStatusException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidLifecycleEventHookExecutionStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidLifecycleEventHookExecutionStatusException) => any;
+}
+
+export interface LifecycleEventAlreadyCompletedException extends __SmithyException, $MetadataBearer {
+    name: "LifecycleEventAlreadyCompletedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LifecycleEventAlreadyCompletedException {
+    
+    const filterSensitiveLog: (obj: LifecycleEventAlreadyCompletedException) => any;
+}
+export interface PutLifecycleEventHookExecutionStatusInput {
+    
+    deploymentId?: string;
+    
+    lifecycleEventHookExecutionId?: string;
+    
+    status?: LifecycleEventStatus | string;
+}
+export declare namespace PutLifecycleEventHookExecutionStatusInput {
+    
+    const filterSensitiveLog: (obj: PutLifecycleEventHookExecutionStatusInput) => any;
+}
+export interface PutLifecycleEventHookExecutionStatusOutput {
+    
+    lifecycleEventHookExecutionId?: string;
+}
+export declare namespace PutLifecycleEventHookExecutionStatusOutput {
+    
+    const filterSensitiveLog: (obj: PutLifecycleEventHookExecutionStatusOutput) => any;
+}
+
+export interface RegisterApplicationRevisionInput {
+    
+    applicationName: string | undefined;
+    
+    description?: string;
+    
+    revision: RevisionLocation | undefined;
+}
+export declare namespace RegisterApplicationRevisionInput {
+    
+    const filterSensitiveLog: (obj: RegisterApplicationRevisionInput) => any;
+}
+
+export interface IamArnRequiredException extends __SmithyException, $MetadataBearer {
+    name: "IamArnRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace IamArnRequiredException {
+    
+    const filterSensitiveLog: (obj: IamArnRequiredException) => any;
+}
+
+export interface IamSessionArnAlreadyRegisteredException extends __SmithyException, $MetadataBearer {
+    name: "IamSessionArnAlreadyRegisteredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace IamSessionArnAlreadyRegisteredException {
+    
+    const filterSensitiveLog: (obj: IamSessionArnAlreadyRegisteredException) => any;
+}
+
+export interface IamUserArnAlreadyRegisteredException extends __SmithyException, $MetadataBearer {
+    name: "IamUserArnAlreadyRegisteredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace IamUserArnAlreadyRegisteredException {
+    
+    const filterSensitiveLog: (obj: IamUserArnAlreadyRegisteredException) => any;
+}
+
+export interface IamUserArnRequiredException extends __SmithyException, $MetadataBearer {
+    name: "IamUserArnRequiredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace IamUserArnRequiredException {
+    
+    const filterSensitiveLog: (obj: IamUserArnRequiredException) => any;
+}
+
+export interface InstanceNameAlreadyRegisteredException extends __SmithyException, $MetadataBearer {
+    name: "InstanceNameAlreadyRegisteredException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InstanceNameAlreadyRegisteredException {
+    
+    const filterSensitiveLog: (obj: InstanceNameAlreadyRegisteredException) => any;
+}
+
+export interface InvalidIamSessionArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidIamSessionArnException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidIamSessionArnException {
+    
+    const filterSensitiveLog: (obj: InvalidIamSessionArnException) => any;
+}
+
+export interface InvalidIamUserArnException extends __SmithyException, $MetadataBearer {
+    name: "InvalidIamUserArnException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace InvalidIamUserArnException {
+    
+    const filterSensitiveLog: (obj: InvalidIamUserArnException) => any;
+}
+
+export interface MultipleIamArnsProvidedException extends __SmithyException, $MetadataBearer {
+    name: "MultipleIamArnsProvidedException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace MultipleIamArnsProvidedException {
+    
+    const filterSensitiveLog: (obj: MultipleIamArnsProvidedException) => any;
+}
+
+export interface RegisterOnPremisesInstanceInput {
+    
+    instanceName: string | undefined;
+    
+    iamSessionArn?: string;
+    
+    iamUserArn?: string;
+}
+export declare namespace RegisterOnPremisesInstanceInput {
+    
+    const filterSensitiveLog: (obj: RegisterOnPremisesInstanceInput) => any;
+}
+
+export interface RemoveTagsFromOnPremisesInstancesInput {
+    
+    tags: Tag[] | undefined;
+    
+    instanceNames: string[] | undefined;
+}
+export declare namespace RemoveTagsFromOnPremisesInstancesInput {
+    
+    const filterSensitiveLog: (obj: RemoveTagsFromOnPremisesInstancesInput) => any;
+}
+export interface SkipWaitTimeForInstanceTerminationInput {
+    
+    deploymentId?: string;
+}
+export declare namespace SkipWaitTimeForInstanceTerminationInput {
+    
+    const filterSensitiveLog: (obj: SkipWaitTimeForInstanceTerminationInput) => any;
+}
+
+export interface StopDeploymentInput {
+    
+    deploymentId: string | undefined;
+    
+    autoRollbackEnabled?: boolean;
+}
+export declare namespace StopDeploymentInput {
+    
+    const filterSensitiveLog: (obj: StopDeploymentInput) => any;
+}
+export declare enum StopStatus {
+    PENDING = "Pending",
+    SUCCEEDED = "Succeeded"
+}
+
+export interface StopDeploymentOutput {
+    
+    status?: StopStatus | string;
+    
+    statusMessage?: string;
+}
+export declare namespace StopDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: StopDeploymentOutput) => any;
+}
+export interface TagResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+export interface UntagResourceInput {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}
+
+export interface UpdateApplicationInput {
+    
+    applicationName?: string;
+    
+    newApplicationName?: string;
+}
+export declare namespace UpdateApplicationInput {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationInput) => any;
+}
+
+export interface UpdateDeploymentGroupInput {
+    
+    applicationName: string | undefined;
+    
+    currentDeploymentGroupName: string | undefined;
+    
+    newDeploymentGroupName?: string;
+    
+    deploymentConfigName?: string;
+    
+    ec2TagFilters?: EC2TagFilter[];
+    
+    onPremisesInstanceTagFilters?: TagFilter[];
+    
+    autoScalingGroups?: string[];
+    
+    serviceRoleArn?: string;
+    
+    triggerConfigurations?: TriggerConfig[];
+    
+    alarmConfiguration?: AlarmConfiguration;
+    
+    autoRollbackConfiguration?: AutoRollbackConfiguration;
+    
+    outdatedInstancesStrategy?: OutdatedInstancesStrategy | string;
+    
+    deploymentStyle?: DeploymentStyle;
+    
+    blueGreenDeploymentConfiguration?: BlueGreenDeploymentConfiguration;
+    
+    loadBalancerInfo?: LoadBalancerInfo;
+    
+    ec2TagSet?: EC2TagSet;
+    
+    ecsServices?: ECSService[];
+    
+    onPremisesTagSet?: OnPremisesTagSet;
+}
+export declare namespace UpdateDeploymentGroupInput {
+    
+    const filterSensitiveLog: (obj: UpdateDeploymentGroupInput) => any;
+}
+
+export interface UpdateDeploymentGroupOutput {
+    
+    hooksNotCleanedUp?: AutoScalingGroup[];
+}
+export declare namespace UpdateDeploymentGroupOutput {
+    
+    const filterSensitiveLog: (obj: UpdateDeploymentGroupOutput) => any;
+}