import type { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
import { CodeDeployServiceException as __BaseException } from "./CodeDeployServiceException";
/**
 * <p>The maximum number of allowed on-premises instances in a single call was
 *             exceeded.</p>
 * @public
 */
export declare class InstanceLimitExceededException extends __BaseException {
    readonly name: "InstanceLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceLimitExceededException, __BaseException>);
}
/**
 * <p>An on-premises instance name was not specified.</p>
 * @public
 */
export declare class InstanceNameRequiredException extends __BaseException {
    readonly name: "InstanceNameRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceNameRequiredException, __BaseException>);
}
/**
 * <p>The specified on-premises instance is not registered.</p>
 * @public
 */
export declare class InstanceNotRegisteredException extends __BaseException {
    readonly name: "InstanceNotRegisteredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceNotRegisteredException, __BaseException>);
}
/**
 * <p>The on-premises instance name was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidInstanceNameException extends __BaseException {
    readonly name: "InvalidInstanceNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidInstanceNameException, __BaseException>);
}
/**
 * <p>The tag was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidTagException extends __BaseException {
    readonly name: "InvalidTagException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTagException, __BaseException>);
}
/**
 * <p>The maximum allowed number of tags was exceeded.</p>
 * @public
 */
export declare class TagLimitExceededException extends __BaseException {
    readonly name: "TagLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TagLimitExceededException, __BaseException>);
}
/**
 * <p>A tag was not specified.</p>
 * @public
 */
export declare class TagRequiredException extends __BaseException {
    readonly name: "TagRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TagRequiredException, __BaseException>);
}
/**
 * <p>The maximum number of alarms for a deployment group (10) was exceeded.</p>
 * @public
 */
export declare class AlarmsLimitExceededException extends __BaseException {
    readonly name: "AlarmsLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<AlarmsLimitExceededException, __BaseException>);
}
/**
 * <p>An application with the specified name with the user or Amazon Web Services account
 *             already exists.</p>
 * @public
 */
export declare class ApplicationAlreadyExistsException extends __BaseException {
    readonly name: "ApplicationAlreadyExistsException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ApplicationAlreadyExistsException, __BaseException>);
}
/**
 * <p>The application does not exist with the user or Amazon Web Services account.</p>
 * @public
 */
export declare class ApplicationDoesNotExistException extends __BaseException {
    readonly name: "ApplicationDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ApplicationDoesNotExistException, __BaseException>);
}
/**
 * <p>More applications were attempted to be created than are allowed.</p>
 * @public
 */
export declare class ApplicationLimitExceededException extends __BaseException {
    readonly name: "ApplicationLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ApplicationLimitExceededException, __BaseException>);
}
/**
 * <p>The minimum number of required application names was not specified.</p>
 * @public
 */
export declare class ApplicationNameRequiredException extends __BaseException {
    readonly name: "ApplicationNameRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ApplicationNameRequiredException, __BaseException>);
}
/**
 * <p> The specified ARN is not supported. For example, it might be an ARN for a resource
 *             that is not expected. </p>
 * @public
 */
export declare class ArnNotSupportedException extends __BaseException {
    readonly name: "ArnNotSupportedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ArnNotSupportedException, __BaseException>);
}
/**
 * <p>The maximum number of names or IDs allowed for this request (100) was exceeded.</p>
 * @public
 */
export declare class BatchLimitExceededException extends __BaseException {
    readonly name: "BatchLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BatchLimitExceededException, __BaseException>);
}
/**
 * <p>The application name was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidApplicationNameException extends __BaseException {
    readonly name: "InvalidApplicationNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidApplicationNameException, __BaseException>);
}
/**
 * <p>The revision was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidRevisionException extends __BaseException {
    readonly name: "InvalidRevisionException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRevisionException, __BaseException>);
}
/**
 * <p>The revision ID was not specified.</p>
 * @public
 */
export declare class RevisionRequiredException extends __BaseException {
    readonly name: "RevisionRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RevisionRequiredException, __BaseException>);
}
/**
 * <p>The deployment configuration does not exist with the user or Amazon Web Services account.</p>
 * @public
 */
export declare class DeploymentConfigDoesNotExistException extends __BaseException {
    readonly name: "DeploymentConfigDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentConfigDoesNotExistException, __BaseException>);
}
/**
 * <p>The deployment group name was not specified.</p>
 * @public
 */
export declare class DeploymentGroupNameRequiredException extends __BaseException {
    readonly name: "DeploymentGroupNameRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentGroupNameRequiredException, __BaseException>);
}
/**
 * <p>The deployment group name was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidDeploymentGroupNameException extends __BaseException {
    readonly name: "InvalidDeploymentGroupNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentGroupNameException, __BaseException>);
}
/**
 * <p>The deployment with the user or Amazon Web Services account does not exist.</p>
 * @public
 */
export declare class DeploymentDoesNotExistException extends __BaseException {
    readonly name: "DeploymentDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentDoesNotExistException, __BaseException>);
}
/**
 * <p>At least one deployment ID must be specified.</p>
 * @public
 */
export declare class DeploymentIdRequiredException extends __BaseException {
    readonly name: "DeploymentIdRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentIdRequiredException, __BaseException>);
}
/**
 * <p>The instance ID was not specified.</p>
 *
 * @deprecated This exception is deprecated, use DeploymentTargetIdRequiredException instead.
 * @public
 */
export declare class InstanceIdRequiredException extends __BaseException {
    readonly name: "InstanceIdRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceIdRequiredException, __BaseException>);
}
/**
 * <p>The computePlatform is invalid. The computePlatform should be <code>Lambda</code>, <code>Server</code>, or <code>ECS</code>.</p>
 * @public
 */
export declare class InvalidComputePlatformException extends __BaseException {
    readonly name: "InvalidComputePlatformException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidComputePlatformException, __BaseException>);
}
/**
 * <p>At least one of the deployment IDs was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidDeploymentIdException extends __BaseException {
    readonly name: "InvalidDeploymentIdException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentIdException, __BaseException>);
}
/**
 * <p>The specified deployment has not started.</p>
 * @public
 */
export declare class DeploymentNotStartedException extends __BaseException {
    readonly name: "DeploymentNotStartedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentNotStartedException, __BaseException>);
}
/**
 * <p> The provided target ID does not belong to the attempted deployment. </p>
 * @public
 */
export declare class DeploymentTargetDoesNotExistException extends __BaseException {
    readonly name: "DeploymentTargetDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentTargetDoesNotExistException, __BaseException>);
}
/**
 * <p> A deployment target ID was not provided. </p>
 * @public
 */
export declare class DeploymentTargetIdRequiredException extends __BaseException {
    readonly name: "DeploymentTargetIdRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentTargetIdRequiredException, __BaseException>);
}
/**
 * <p> The maximum number of targets that can be associated with an Amazon ECS or
 *                 Lambda deployment was exceeded. The target list of both types of
 *             deployments must have exactly one item. This exception does not apply to EC2/On-premises
 *             deployments. </p>
 * @public
 */
export declare class DeploymentTargetListSizeExceededException extends __BaseException {
    readonly name: "DeploymentTargetListSizeExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentTargetListSizeExceededException, __BaseException>);
}
/**
 * <p>The specified instance does not exist in the deployment group.</p>
 *
 * @deprecated This exception is deprecated, use DeploymentTargetDoesNotExistException instead.
 * @public
 */
export declare class InstanceDoesNotExistException extends __BaseException {
    readonly name: "InstanceDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceDoesNotExistException, __BaseException>);
}
/**
 * <p> The target ID provided was not valid. </p>
 * @public
 */
export declare class InvalidDeploymentTargetIdException extends __BaseException {
    readonly name: "InvalidDeploymentTargetIdException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentTargetIdException, __BaseException>);
}
/**
 * <p>A bucket name is required, but was not provided.</p>
 * @public
 */
export declare class BucketNameFilterRequiredException extends __BaseException {
    readonly name: "BucketNameFilterRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<BucketNameFilterRequiredException, __BaseException>);
}
/**
 * <p>The deployment is already complete.</p>
 * @public
 */
export declare class DeploymentAlreadyCompletedException extends __BaseException {
    readonly name: "DeploymentAlreadyCompletedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentAlreadyCompletedException, __BaseException>);
}
/**
 * <p>The deployment does not have a status of Ready and can't continue yet.</p>
 * @public
 */
export declare class DeploymentIsNotInReadyStateException extends __BaseException {
    readonly name: "DeploymentIsNotInReadyStateException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentIsNotInReadyStateException, __BaseException>);
}
/**
 * <p>The specified deployment status doesn't exist or cannot be determined.</p>
 * @public
 */
export declare class InvalidDeploymentStatusException extends __BaseException {
    readonly name: "InvalidDeploymentStatusException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentStatusException, __BaseException>);
}
/**
 * <p> The wait type is invalid. </p>
 * @public
 */
export declare class InvalidDeploymentWaitTypeException extends __BaseException {
    readonly name: "InvalidDeploymentWaitTypeException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentWaitTypeException, __BaseException>);
}
/**
 * <p>A call was submitted that is not supported for the specified deployment type.</p>
 * @public
 */
export declare class UnsupportedActionForDeploymentTypeException extends __BaseException {
    readonly name: "UnsupportedActionForDeploymentTypeException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<UnsupportedActionForDeploymentTypeException, __BaseException>);
}
/**
 * <p> The specified tags are not valid. </p>
 * @public
 */
export declare class InvalidTagsToAddException extends __BaseException {
    readonly name: "InvalidTagsToAddException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTagsToAddException, __BaseException>);
}
/**
 * <p>The named deployment group with the user or Amazon Web Services account does not
 *             exist.</p>
 * @public
 */
export declare class DeploymentGroupDoesNotExistException extends __BaseException {
    readonly name: "DeploymentGroupDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentGroupDoesNotExistException, __BaseException>);
}
/**
 * <p>The number of allowed deployments was exceeded.</p>
 * @public
 */
export declare class DeploymentLimitExceededException extends __BaseException {
    readonly name: "DeploymentLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentLimitExceededException, __BaseException>);
}
/**
 * <p>The description is too long.</p>
 * @public
 */
export declare class DescriptionTooLongException extends __BaseException {
    readonly name: "DescriptionTooLongException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DescriptionTooLongException, __BaseException>);
}
/**
 * <p>The format of the alarm configuration is invalid. Possible causes include:</p>
 *          <ul>
 *             <li>
 *                <p>The alarm list is null.</p>
 *             </li>
 *             <li>
 *                <p>The alarm object is null.</p>
 *             </li>
 *             <li>
 *                <p>The alarm name is empty or null or exceeds the limit of 255 characters.</p>
 *             </li>
 *             <li>
 *                <p>Two alarms with the same name have been specified.</p>
 *             </li>
 *             <li>
 *                <p>The alarm configuration is enabled, but the alarm list is empty.</p>
 *             </li>
 *          </ul>
 * @public
 */
export declare class InvalidAlarmConfigException extends __BaseException {
    readonly name: "InvalidAlarmConfigException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAlarmConfigException, __BaseException>);
}
/**
 * <p>The automatic rollback configuration was specified in an invalid format. For example,
 *             automatic rollback is enabled, but an invalid triggering event type or no event types
 *             were listed.</p>
 * @public
 */
export declare class InvalidAutoRollbackConfigException extends __BaseException {
    readonly name: "InvalidAutoRollbackConfigException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAutoRollbackConfigException, __BaseException>);
}
/**
 * <p>The Auto Scaling group was specified in an invalid format or does not
 *             exist.</p>
 * @public
 */
export declare class InvalidAutoScalingGroupException extends __BaseException {
    readonly name: "InvalidAutoScalingGroupException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidAutoScalingGroupException, __BaseException>);
}
/**
 * <p>The deployment configuration name was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidDeploymentConfigNameException extends __BaseException {
    readonly name: "InvalidDeploymentConfigNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentConfigNameException, __BaseException>);
}
/**
 * <p>An invalid fileExistsBehavior option was specified to determine how CodeDeploy handles files or directories that already exist in a deployment
 *             target location, but weren't part of the previous successful deployment. Valid values
 *             include "DISALLOW," "OVERWRITE," and "RETAIN."</p>
 * @public
 */
export declare class InvalidFileExistsBehaviorException extends __BaseException {
    readonly name: "InvalidFileExistsBehaviorException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidFileExistsBehaviorException, __BaseException>);
}
/**
 * <p>The GitHub token is not valid.</p>
 * @public
 */
export declare class InvalidGitHubAccountTokenException extends __BaseException {
    readonly name: "InvalidGitHubAccountTokenException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidGitHubAccountTokenException, __BaseException>);
}
/**
 * <p>The IgnoreApplicationStopFailures value is invalid. For Lambda
 *             deployments, <code>false</code> is expected. For EC2/On-premises deployments,
 *                 <code>true</code> or <code>false</code> is expected.</p>
 * @public
 */
export declare class InvalidIgnoreApplicationStopFailuresValueException extends __BaseException {
    readonly name: "InvalidIgnoreApplicationStopFailuresValueException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidIgnoreApplicationStopFailuresValueException, __BaseException>);
}
/**
 * <p>An invalid load balancer name, or no load balancer name, was specified.</p>
 * @public
 */
export declare class InvalidLoadBalancerInfoException extends __BaseException {
    readonly name: "InvalidLoadBalancerInfoException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidLoadBalancerInfoException, __BaseException>);
}
/**
 * <p>The service role ARN was specified in an invalid format. Or, if an Auto Scaling
 *             group was specified, the specified service role does not grant the appropriate
 *             permissions to Amazon EC2 Auto Scaling.</p>
 * @public
 */
export declare class InvalidRoleException extends __BaseException {
    readonly name: "InvalidRoleException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRoleException, __BaseException>);
}
/**
 * <p>The target instance configuration is invalid. Possible causes include:</p>
 *          <ul>
 *             <li>
 *                <p>Configuration data for target instances was entered for an in-place
 *                     deployment.</p>
 *             </li>
 *             <li>
 *                <p>The limit of 10 tags for a tag type was exceeded.</p>
 *             </li>
 *             <li>
 *                <p>The combined length of the tag names exceeded the limit. </p>
 *             </li>
 *             <li>
 *                <p>A specified tag is not currently applied to any instances.</p>
 *             </li>
 *          </ul>
 * @public
 */
export declare class InvalidTargetInstancesException extends __BaseException {
    readonly name: "InvalidTargetInstancesException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTargetInstancesException, __BaseException>);
}
/**
 * <p> The configuration that specifies how traffic is routed during a deployment is
 *             invalid.</p>
 * @public
 */
export declare class InvalidTrafficRoutingConfigurationException extends __BaseException {
    readonly name: "InvalidTrafficRoutingConfigurationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTrafficRoutingConfigurationException, __BaseException>);
}
/**
 * <p>The UpdateOutdatedInstancesOnly value is invalid. For Lambda
 *             deployments, <code>false</code> is expected. For EC2/On-premises deployments,
 *                 <code>true</code> or <code>false</code> is expected.</p>
 * @public
 */
export declare class InvalidUpdateOutdatedInstancesOnlyValueException extends __BaseException {
    readonly name: "InvalidUpdateOutdatedInstancesOnlyValueException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidUpdateOutdatedInstancesOnlyValueException, __BaseException>);
}
/**
 * <p>The named revision does not exist with the user or Amazon Web Services account.</p>
 * @public
 */
export declare class RevisionDoesNotExistException extends __BaseException {
    readonly name: "RevisionDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RevisionDoesNotExistException, __BaseException>);
}
/**
 * <p>An API function was called too frequently.</p>
 * @public
 */
export declare class ThrottlingException extends __BaseException {
    readonly name: "ThrottlingException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
}
/**
 * <p>A deployment configuration with the specified name with the user or Amazon Web Services account already exists.</p>
 * @public
 */
export declare class DeploymentConfigAlreadyExistsException extends __BaseException {
    readonly name: "DeploymentConfigAlreadyExistsException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentConfigAlreadyExistsException, __BaseException>);
}
/**
 * <p>The deployment configurations limit was exceeded.</p>
 * @public
 */
export declare class DeploymentConfigLimitExceededException extends __BaseException {
    readonly name: "DeploymentConfigLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentConfigLimitExceededException, __BaseException>);
}
/**
 * <p>The deployment configuration name was not specified.</p>
 * @public
 */
export declare class DeploymentConfigNameRequiredException extends __BaseException {
    readonly name: "DeploymentConfigNameRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentConfigNameRequiredException, __BaseException>);
}
/**
 * <p>The minimum healthy instance value was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidMinimumHealthyHostValueException extends __BaseException {
    readonly name: "InvalidMinimumHealthyHostValueException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidMinimumHealthyHostValueException, __BaseException>);
}
/**
 * <p>The <code>ZonalConfig</code> object is not valid.</p>
 * @public
 */
export declare class InvalidZonalDeploymentConfigurationException extends __BaseException {
    readonly name: "InvalidZonalDeploymentConfigurationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidZonalDeploymentConfigurationException, __BaseException>);
}
/**
 * <p>A deployment group with the specified name with the user or Amazon Web Services account
 *             already exists.</p>
 * @public
 */
export declare class DeploymentGroupAlreadyExistsException extends __BaseException {
    readonly name: "DeploymentGroupAlreadyExistsException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentGroupAlreadyExistsException, __BaseException>);
}
/**
 * <p> The deployment groups limit was exceeded.</p>
 * @public
 */
export declare class DeploymentGroupLimitExceededException extends __BaseException {
    readonly name: "DeploymentGroupLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentGroupLimitExceededException, __BaseException>);
}
/**
 * <p> The Amazon ECS service is associated with more than one deployment groups. An
 *             Amazon ECS service can be associated with only one deployment group. </p>
 * @public
 */
export declare class ECSServiceMappingLimitExceededException extends __BaseException {
    readonly name: "ECSServiceMappingLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ECSServiceMappingLimitExceededException, __BaseException>);
}
/**
 * <p>The configuration for the blue/green deployment group was provided in an invalid
 *             format. For information about deployment configuration format, see <a>CreateDeploymentConfig</a>.</p>
 * @public
 */
export declare class InvalidBlueGreenDeploymentConfigurationException extends __BaseException {
    readonly name: "InvalidBlueGreenDeploymentConfigurationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidBlueGreenDeploymentConfigurationException, __BaseException>);
}
/**
 * <p>An invalid deployment style was specified. Valid deployment types include "IN_PLACE"
 *             and "BLUE_GREEN." Valid deployment options include "WITH_TRAFFIC_CONTROL" and
 *             "WITHOUT_TRAFFIC_CONTROL."</p>
 * @public
 */
export declare class InvalidDeploymentStyleException extends __BaseException {
    readonly name: "InvalidDeploymentStyleException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentStyleException, __BaseException>);
}
/**
 * <p>A call was submitted that specified both Ec2TagFilters and Ec2TagSet, but only one of
 *             these data types can be used in a single call.</p>
 * @public
 */
export declare class InvalidEC2TagCombinationException extends __BaseException {
    readonly name: "InvalidEC2TagCombinationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEC2TagCombinationException, __BaseException>);
}
/**
 * <p>The tag was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidEC2TagException extends __BaseException {
    readonly name: "InvalidEC2TagException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidEC2TagException, __BaseException>);
}
/**
 * <p> The Amazon ECS service identifier is not valid. </p>
 * @public
 */
export declare class InvalidECSServiceException extends __BaseException {
    readonly name: "InvalidECSServiceException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidECSServiceException, __BaseException>);
}
/**
 * <p>The input was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidInputException extends __BaseException {
    readonly name: "InvalidInputException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidInputException, __BaseException>);
}
/**
 * <p>A call was submitted that specified both OnPremisesTagFilters and OnPremisesTagSet,
 *             but only one of these data types can be used in a single call.</p>
 * @public
 */
export declare class InvalidOnPremisesTagCombinationException extends __BaseException {
    readonly name: "InvalidOnPremisesTagCombinationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidOnPremisesTagCombinationException, __BaseException>);
}
/**
 * <p> A target group pair associated with this deployment is not valid. </p>
 * @public
 */
export declare class InvalidTargetGroupPairException extends __BaseException {
    readonly name: "InvalidTargetGroupPairException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTargetGroupPairException, __BaseException>);
}
/**
 * <p>The trigger was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidTriggerConfigException extends __BaseException {
    readonly name: "InvalidTriggerConfigException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTriggerConfigException, __BaseException>);
}
/**
 * <p>The limit for lifecycle hooks was exceeded.</p>
 * @public
 */
export declare class LifecycleHookLimitExceededException extends __BaseException {
    readonly name: "LifecycleHookLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LifecycleHookLimitExceededException, __BaseException>);
}
/**
 * <p>The role ID was not specified.</p>
 * @public
 */
export declare class RoleRequiredException extends __BaseException {
    readonly name: "RoleRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<RoleRequiredException, __BaseException>);
}
/**
 * <p>The number of tag groups included in the tag set list exceeded the maximum allowed
 *             limit of 3.</p>
 * @public
 */
export declare class TagSetListLimitExceededException extends __BaseException {
    readonly name: "TagSetListLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TagSetListLimitExceededException, __BaseException>);
}
/**
 * <p>The maximum allowed number of triggers was exceeded.</p>
 * @public
 */
export declare class TriggerTargetsLimitExceededException extends __BaseException {
    readonly name: "TriggerTargetsLimitExceededException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<TriggerTargetsLimitExceededException, __BaseException>);
}
/**
 * <p>The deployment configuration is still in use.</p>
 * @public
 */
export declare class DeploymentConfigInUseException extends __BaseException {
    readonly name: "DeploymentConfigInUseException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<DeploymentConfigInUseException, __BaseException>);
}
/**
 * <p>An invalid operation was detected.</p>
 * @public
 */
export declare class InvalidOperationException extends __BaseException {
    readonly name: "InvalidOperationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidOperationException, __BaseException>);
}
/**
 * <p>No GitHub account connection exists with the named specified in the call.</p>
 * @public
 */
export declare class GitHubAccountTokenDoesNotExistException extends __BaseException {
    readonly name: "GitHubAccountTokenDoesNotExistException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GitHubAccountTokenDoesNotExistException, __BaseException>);
}
/**
 * <p>The call is missing a required GitHub account connection name.</p>
 * @public
 */
export declare class GitHubAccountTokenNameRequiredException extends __BaseException {
    readonly name: "GitHubAccountTokenNameRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<GitHubAccountTokenNameRequiredException, __BaseException>);
}
/**
 * <p>The format of the specified GitHub account connection name is invalid.</p>
 * @public
 */
export declare class InvalidGitHubAccountTokenNameException extends __BaseException {
    readonly name: "InvalidGitHubAccountTokenNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidGitHubAccountTokenNameException, __BaseException>);
}
/**
 * <p>The API used does not support the deployment.</p>
 * @public
 */
export declare class OperationNotSupportedException extends __BaseException {
    readonly name: "OperationNotSupportedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<OperationNotSupportedException, __BaseException>);
}
/**
 * <p>The specified resource could not be validated.</p>
 * @public
 */
export declare class ResourceValidationException extends __BaseException {
    readonly name: "ResourceValidationException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceValidationException, __BaseException>);
}
/**
 * <p>The bucket name either doesn't exist or was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidBucketNameFilterException extends __BaseException {
    readonly name: "InvalidBucketNameFilterException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidBucketNameFilterException, __BaseException>);
}
/**
 * <p>The deployed state filter was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidDeployedStateFilterException extends __BaseException {
    readonly name: "InvalidDeployedStateFilterException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeployedStateFilterException, __BaseException>);
}
/**
 * <p>The specified key prefix filter was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidKeyPrefixFilterException extends __BaseException {
    readonly name: "InvalidKeyPrefixFilterException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidKeyPrefixFilterException, __BaseException>);
}
/**
 * <p>The next token was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidNextTokenException extends __BaseException {
    readonly name: "InvalidNextTokenException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
}
/**
 * <p>The column name to sort by is either not present or was specified in an invalid
 *             format.</p>
 * @public
 */
export declare class InvalidSortByException extends __BaseException {
    readonly name: "InvalidSortByException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSortByException, __BaseException>);
}
/**
 * <p>The sort order was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidSortOrderException extends __BaseException {
    readonly name: "InvalidSortOrderException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidSortOrderException, __BaseException>);
}
/**
 * <p>An instance type was specified for an in-place deployment. Instance types are
 *             supported for blue/green deployments only.</p>
 * @public
 */
export declare class InvalidDeploymentInstanceTypeException extends __BaseException {
    readonly name: "InvalidDeploymentInstanceTypeException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidDeploymentInstanceTypeException, __BaseException>);
}
/**
 * <p>The specified instance status does not exist.</p>
 * @public
 */
export declare class InvalidInstanceStatusException extends __BaseException {
    readonly name: "InvalidInstanceStatusException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidInstanceStatusException, __BaseException>);
}
/**
 * <p>An invalid instance type was specified for instances in a blue/green deployment. Valid
 *             values include "Blue" for an original environment and "Green" for a replacement
 *             environment.</p>
 * @public
 */
export declare class InvalidInstanceTypeException extends __BaseException {
    readonly name: "InvalidInstanceTypeException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidInstanceTypeException, __BaseException>);
}
/**
 * <p> The target filter name is invalid. </p>
 * @public
 */
export declare class InvalidTargetFilterNameException extends __BaseException {
    readonly name: "InvalidTargetFilterNameException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTargetFilterNameException, __BaseException>);
}
/**
 * <p>The external ID was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidExternalIdException extends __BaseException {
    readonly name: "InvalidExternalIdException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidExternalIdException, __BaseException>);
}
/**
 * <p>The specified time range was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidTimeRangeException extends __BaseException {
    readonly name: "InvalidTimeRangeException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTimeRangeException, __BaseException>);
}
/**
 * <p>The registration status was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidRegistrationStatusException extends __BaseException {
    readonly name: "InvalidRegistrationStatusException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidRegistrationStatusException, __BaseException>);
}
/**
 * <p>The tag filter was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidTagFilterException extends __BaseException {
    readonly name: "InvalidTagFilterException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidTagFilterException, __BaseException>);
}
/**
 * <p> The specified ARN is not in a valid format. </p>
 * @public
 */
export declare class InvalidArnException extends __BaseException {
    readonly name: "InvalidArnException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidArnException, __BaseException>);
}
/**
 * <p> The ARN of a resource is required, but was not found. </p>
 * @public
 */
export declare class ResourceArnRequiredException extends __BaseException {
    readonly name: "ResourceArnRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<ResourceArnRequiredException, __BaseException>);
}
/**
 * <p>A lifecycle event hook is invalid. Review the <code>hooks</code> section in your
 *             AppSpec file to ensure the lifecycle events and <code>hooks</code> functions are
 *             valid.</p>
 * @public
 */
export declare class InvalidLifecycleEventHookExecutionIdException extends __BaseException {
    readonly name: "InvalidLifecycleEventHookExecutionIdException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidLifecycleEventHookExecutionIdException, __BaseException>);
}
/**
 * <p>The result of a Lambda validation function that verifies a lifecycle event
 *             is invalid. It should return <code>Succeeded</code> or <code>Failed</code>.</p>
 * @public
 */
export declare class InvalidLifecycleEventHookExecutionStatusException extends __BaseException {
    readonly name: "InvalidLifecycleEventHookExecutionStatusException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidLifecycleEventHookExecutionStatusException, __BaseException>);
}
/**
 * <p>An attempt to return the status of an already completed lifecycle event
 *             occurred.</p>
 * @public
 */
export declare class LifecycleEventAlreadyCompletedException extends __BaseException {
    readonly name: "LifecycleEventAlreadyCompletedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<LifecycleEventAlreadyCompletedException, __BaseException>);
}
/**
 * <p>No IAM ARN was included in the request. You must use an IAM session ARN or user ARN in the request.</p>
 * @public
 */
export declare class IamArnRequiredException extends __BaseException {
    readonly name: "IamArnRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamArnRequiredException, __BaseException>);
}
/**
 * <p>The request included an IAM session ARN that has already been used to
 *             register a different instance.</p>
 * @public
 */
export declare class IamSessionArnAlreadyRegisteredException extends __BaseException {
    readonly name: "IamSessionArnAlreadyRegisteredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamSessionArnAlreadyRegisteredException, __BaseException>);
}
/**
 * <p>The specified user ARN is already registered with an on-premises instance.</p>
 * @public
 */
export declare class IamUserArnAlreadyRegisteredException extends __BaseException {
    readonly name: "IamUserArnAlreadyRegisteredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamUserArnAlreadyRegisteredException, __BaseException>);
}
/**
 * <p>An user ARN was not specified.</p>
 * @public
 */
export declare class IamUserArnRequiredException extends __BaseException {
    readonly name: "IamUserArnRequiredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<IamUserArnRequiredException, __BaseException>);
}
/**
 * <p>The specified on-premises instance name is already registered.</p>
 * @public
 */
export declare class InstanceNameAlreadyRegisteredException extends __BaseException {
    readonly name: "InstanceNameAlreadyRegisteredException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InstanceNameAlreadyRegisteredException, __BaseException>);
}
/**
 * <p>The IAM session ARN was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidIamSessionArnException extends __BaseException {
    readonly name: "InvalidIamSessionArnException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidIamSessionArnException, __BaseException>);
}
/**
 * <p>The user ARN was specified in an invalid format.</p>
 * @public
 */
export declare class InvalidIamUserArnException extends __BaseException {
    readonly name: "InvalidIamUserArnException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<InvalidIamUserArnException, __BaseException>);
}
/**
 * <p>Both an user ARN and an IAM session ARN were included in the request.
 *             Use only one ARN type.</p>
 * @public
 */
export declare class MultipleIamArnsProvidedException extends __BaseException {
    readonly name: "MultipleIamArnsProvidedException";
    readonly $fault: "client";
    /**
     * @internal
     */
    constructor(opts: __ExceptionOptionType<MultipleIamArnsProvidedException, __BaseException>);
}
