@aws-sdk/client-elastic-beanstalk 3.50.0 → 3.53.0

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

@@ -0,0 +1,2006 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ElasticBeanstalkServiceException as __BaseException } from "./ElasticBeanstalkServiceException";
+
+export interface AbortEnvironmentUpdateMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace AbortEnvironmentUpdateMessage {
+    
+    const filterSensitiveLog: (obj: AbortEnvironmentUpdateMessage) => any;
+}
+
+export declare class InsufficientPrivilegesException extends __BaseException {
+    readonly name: "InsufficientPrivilegesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InsufficientPrivilegesException, __BaseException>);
+}
+export declare type ActionHistoryStatus = "Completed" | "Failed" | "Unknown";
+export declare type ActionStatus = "Pending" | "Running" | "Scheduled" | "Unknown";
+export declare type ActionType = "InstanceRefresh" | "PlatformUpdate" | "Unknown";
+
+export interface MaxAgeRule {
+    
+    Enabled: boolean | undefined;
+    
+    MaxAgeInDays?: number;
+    
+    DeleteSourceFromS3?: boolean;
+}
+export declare namespace MaxAgeRule {
+    
+    const filterSensitiveLog: (obj: MaxAgeRule) => any;
+}
+
+export interface MaxCountRule {
+    
+    Enabled: boolean | undefined;
+    
+    MaxCount?: number;
+    
+    DeleteSourceFromS3?: boolean;
+}
+export declare namespace MaxCountRule {
+    
+    const filterSensitiveLog: (obj: MaxCountRule) => any;
+}
+
+export interface ApplicationVersionLifecycleConfig {
+    
+    MaxCountRule?: MaxCountRule;
+    
+    MaxAgeRule?: MaxAgeRule;
+}
+export declare namespace ApplicationVersionLifecycleConfig {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionLifecycleConfig) => any;
+}
+
+export interface ApplicationResourceLifecycleConfig {
+    
+    ServiceRole?: string;
+    
+    VersionLifecycleConfig?: ApplicationVersionLifecycleConfig;
+}
+export declare namespace ApplicationResourceLifecycleConfig {
+    
+    const filterSensitiveLog: (obj: ApplicationResourceLifecycleConfig) => any;
+}
+
+export interface ApplicationDescription {
+    
+    ApplicationArn?: string;
+    
+    ApplicationName?: string;
+    
+    Description?: string;
+    
+    DateCreated?: Date;
+    
+    DateUpdated?: Date;
+    
+    Versions?: string[];
+    
+    ConfigurationTemplates?: string[];
+    
+    ResourceLifecycleConfig?: ApplicationResourceLifecycleConfig;
+}
+export declare namespace ApplicationDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationDescription) => any;
+}
+
+export interface ApplicationDescriptionMessage {
+    
+    Application?: ApplicationDescription;
+}
+export declare namespace ApplicationDescriptionMessage {
+    
+    const filterSensitiveLog: (obj: ApplicationDescriptionMessage) => any;
+}
+
+export interface ApplicationDescriptionsMessage {
+    
+    Applications?: ApplicationDescription[];
+}
+export declare namespace ApplicationDescriptionsMessage {
+    
+    const filterSensitiveLog: (obj: ApplicationDescriptionsMessage) => any;
+}
+
+export interface Latency {
+    
+    P999?: number;
+    
+    P99?: number;
+    
+    P95?: number;
+    
+    P90?: number;
+    
+    P85?: number;
+    
+    P75?: number;
+    
+    P50?: number;
+    
+    P10?: number;
+}
+export declare namespace Latency {
+    
+    const filterSensitiveLog: (obj: Latency) => any;
+}
+
+export interface StatusCodes {
+    
+    Status2xx?: number;
+    
+    Status3xx?: number;
+    
+    Status4xx?: number;
+    
+    Status5xx?: number;
+}
+export declare namespace StatusCodes {
+    
+    const filterSensitiveLog: (obj: StatusCodes) => any;
+}
+
+export interface ApplicationMetrics {
+    
+    Duration?: number;
+    
+    RequestCount?: number;
+    
+    StatusCodes?: StatusCodes;
+    
+    Latency?: Latency;
+}
+export declare namespace ApplicationMetrics {
+    
+    const filterSensitiveLog: (obj: ApplicationMetrics) => any;
+}
+export interface ApplicationResourceLifecycleDescriptionMessage {
+    
+    ApplicationName?: string;
+    
+    ResourceLifecycleConfig?: ApplicationResourceLifecycleConfig;
+}
+export declare namespace ApplicationResourceLifecycleDescriptionMessage {
+    
+    const filterSensitiveLog: (obj: ApplicationResourceLifecycleDescriptionMessage) => any;
+}
+export declare type SourceRepository = "CodeCommit" | "S3";
+export declare type SourceType = "Git" | "Zip";
+
+export interface SourceBuildInformation {
+    
+    SourceType: SourceType | string | undefined;
+    
+    SourceRepository: SourceRepository | string | undefined;
+    
+    SourceLocation: string | undefined;
+}
+export declare namespace SourceBuildInformation {
+    
+    const filterSensitiveLog: (obj: SourceBuildInformation) => any;
+}
+
+export interface S3Location {
+    
+    S3Bucket?: string;
+    
+    S3Key?: string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+export declare type ApplicationVersionStatus = "Building" | "Failed" | "Processed" | "Processing" | "Unprocessed";
+
+export interface ApplicationVersionDescription {
+    
+    ApplicationVersionArn?: string;
+    
+    ApplicationName?: string;
+    
+    Description?: string;
+    
+    VersionLabel?: string;
+    
+    SourceBuildInformation?: SourceBuildInformation;
+    
+    BuildArn?: string;
+    
+    SourceBundle?: S3Location;
+    
+    DateCreated?: Date;
+    
+    DateUpdated?: Date;
+    
+    Status?: ApplicationVersionStatus | string;
+}
+export declare namespace ApplicationVersionDescription {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionDescription) => any;
+}
+
+export interface ApplicationVersionDescriptionMessage {
+    
+    ApplicationVersion?: ApplicationVersionDescription;
+}
+export declare namespace ApplicationVersionDescriptionMessage {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionDescriptionMessage) => any;
+}
+
+export interface ApplicationVersionDescriptionsMessage {
+    
+    ApplicationVersions?: ApplicationVersionDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace ApplicationVersionDescriptionsMessage {
+    
+    const filterSensitiveLog: (obj: ApplicationVersionDescriptionsMessage) => any;
+}
+
+export interface ApplyEnvironmentManagedActionRequest {
+    
+    EnvironmentName?: string;
+    
+    EnvironmentId?: string;
+    
+    ActionId: string | undefined;
+}
+export declare namespace ApplyEnvironmentManagedActionRequest {
+    
+    const filterSensitiveLog: (obj: ApplyEnvironmentManagedActionRequest) => any;
+}
+
+export interface ApplyEnvironmentManagedActionResult {
+    
+    ActionId?: string;
+    
+    ActionDescription?: string;
+    
+    ActionType?: ActionType | string;
+    
+    Status?: string;
+}
+export declare namespace ApplyEnvironmentManagedActionResult {
+    
+    const filterSensitiveLog: (obj: ApplyEnvironmentManagedActionResult) => any;
+}
+
+export declare class ElasticBeanstalkServiceException extends __BaseException {
+    readonly name: "ElasticBeanstalkServiceException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ElasticBeanstalkServiceException, __BaseException>);
+}
+
+export declare class ManagedActionInvalidStateException extends __BaseException {
+    readonly name: "ManagedActionInvalidStateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ManagedActionInvalidStateException, __BaseException>);
+}
+
+export interface AssociateEnvironmentOperationsRoleMessage {
+    
+    EnvironmentName: string | undefined;
+    
+    OperationsRole: string | undefined;
+}
+export declare namespace AssociateEnvironmentOperationsRoleMessage {
+    
+    const filterSensitiveLog: (obj: AssociateEnvironmentOperationsRoleMessage) => any;
+}
+
+export interface AutoScalingGroup {
+    
+    Name?: string;
+}
+export declare namespace AutoScalingGroup {
+    
+    const filterSensitiveLog: (obj: AutoScalingGroup) => any;
+}
+
+export interface SolutionStackDescription {
+    
+    SolutionStackName?: string;
+    
+    PermittedFileTypes?: string[];
+}
+export declare namespace SolutionStackDescription {
+    
+    const filterSensitiveLog: (obj: SolutionStackDescription) => any;
+}
+
+export interface CheckDNSAvailabilityMessage {
+    
+    CNAMEPrefix: string | undefined;
+}
+export declare namespace CheckDNSAvailabilityMessage {
+    
+    const filterSensitiveLog: (obj: CheckDNSAvailabilityMessage) => any;
+}
+
+export interface CheckDNSAvailabilityResultMessage {
+    
+    Available?: boolean;
+    
+    FullyQualifiedCNAME?: string;
+}
+export declare namespace CheckDNSAvailabilityResultMessage {
+    
+    const filterSensitiveLog: (obj: CheckDNSAvailabilityResultMessage) => any;
+}
+
+export interface ComposeEnvironmentsMessage {
+    
+    ApplicationName?: string;
+    
+    GroupName?: string;
+    
+    VersionLabels?: string[];
+}
+export declare namespace ComposeEnvironmentsMessage {
+    
+    const filterSensitiveLog: (obj: ComposeEnvironmentsMessage) => any;
+}
+
+export interface EnvironmentLink {
+    
+    LinkName?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace EnvironmentLink {
+    
+    const filterSensitiveLog: (obj: EnvironmentLink) => any;
+}
+export declare type EnvironmentHealth = "Green" | "Grey" | "Red" | "Yellow";
+export declare type EnvironmentHealthStatus = "Degraded" | "Info" | "NoData" | "Ok" | "Pending" | "Severe" | "Suspended" | "Unknown" | "Warning";
+
+export interface Listener {
+    
+    Protocol?: string;
+    
+    Port?: number;
+}
+export declare namespace Listener {
+    
+    const filterSensitiveLog: (obj: Listener) => any;
+}
+
+export interface LoadBalancerDescription {
+    
+    LoadBalancerName?: string;
+    
+    Domain?: string;
+    
+    Listeners?: Listener[];
+}
+export declare namespace LoadBalancerDescription {
+    
+    const filterSensitiveLog: (obj: LoadBalancerDescription) => any;
+}
+
+export interface EnvironmentResourcesDescription {
+    
+    LoadBalancer?: LoadBalancerDescription;
+}
+export declare namespace EnvironmentResourcesDescription {
+    
+    const filterSensitiveLog: (obj: EnvironmentResourcesDescription) => any;
+}
+export declare type EnvironmentStatus = "Aborting" | "Launching" | "LinkingFrom" | "LinkingTo" | "Ready" | "Terminated" | "Terminating" | "Updating";
+
+export interface EnvironmentTier {
+    
+    Name?: string;
+    
+    Type?: string;
+    
+    Version?: string;
+}
+export declare namespace EnvironmentTier {
+    
+    const filterSensitiveLog: (obj: EnvironmentTier) => any;
+}
+
+export interface EnvironmentDescription {
+    
+    EnvironmentName?: string;
+    
+    EnvironmentId?: string;
+    
+    ApplicationName?: string;
+    
+    VersionLabel?: string;
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    TemplateName?: string;
+    
+    Description?: string;
+    
+    EndpointURL?: string;
+    
+    CNAME?: string;
+    
+    DateCreated?: Date;
+    
+    DateUpdated?: Date;
+    
+    Status?: EnvironmentStatus | string;
+    
+    AbortableOperationInProgress?: boolean;
+    
+    Health?: EnvironmentHealth | string;
+    
+    HealthStatus?: EnvironmentHealthStatus | string;
+    
+    Resources?: EnvironmentResourcesDescription;
+    
+    Tier?: EnvironmentTier;
+    
+    EnvironmentLinks?: EnvironmentLink[];
+    
+    EnvironmentArn?: string;
+    
+    OperationsRole?: string;
+}
+export declare namespace EnvironmentDescription {
+    
+    const filterSensitiveLog: (obj: EnvironmentDescription) => any;
+}
+
+export interface EnvironmentDescriptionsMessage {
+    
+    Environments?: EnvironmentDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace EnvironmentDescriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EnvironmentDescriptionsMessage) => any;
+}
+
+export declare class TooManyEnvironmentsException extends __BaseException {
+    readonly name: "TooManyEnvironmentsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyEnvironmentsException, __BaseException>);
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface CreateApplicationMessage {
+    
+    ApplicationName: string | undefined;
+    
+    Description?: string;
+    
+    ResourceLifecycleConfig?: ApplicationResourceLifecycleConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateApplicationMessage {
+    
+    const filterSensitiveLog: (obj: CreateApplicationMessage) => any;
+}
+
+export declare class TooManyApplicationsException extends __BaseException {
+    readonly name: "TooManyApplicationsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyApplicationsException, __BaseException>);
+}
+
+export declare class CodeBuildNotInServiceRegionException extends __BaseException {
+    readonly name: "CodeBuildNotInServiceRegionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<CodeBuildNotInServiceRegionException, __BaseException>);
+}
+export declare enum ComputeType {
+    BUILD_GENERAL1_LARGE = "BUILD_GENERAL1_LARGE",
+    BUILD_GENERAL1_MEDIUM = "BUILD_GENERAL1_MEDIUM",
+    BUILD_GENERAL1_SMALL = "BUILD_GENERAL1_SMALL"
+}
+
+export interface BuildConfiguration {
+    
+    ArtifactName?: string;
+    
+    CodeBuildServiceRole: string | undefined;
+    
+    ComputeType?: ComputeType | string;
+    
+    Image: string | undefined;
+    
+    TimeoutInMinutes?: number;
+}
+export declare namespace BuildConfiguration {
+    
+    const filterSensitiveLog: (obj: BuildConfiguration) => any;
+}
+
+export interface CreateApplicationVersionMessage {
+    
+    ApplicationName: string | undefined;
+    
+    VersionLabel: string | undefined;
+    
+    Description?: string;
+    
+    SourceBuildInformation?: SourceBuildInformation;
+    
+    SourceBundle?: S3Location;
+    
+    BuildConfiguration?: BuildConfiguration;
+    
+    AutoCreateApplication?: boolean;
+    
+    Process?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateApplicationVersionMessage {
+    
+    const filterSensitiveLog: (obj: CreateApplicationVersionMessage) => any;
+}
+
+export declare class S3LocationNotInServiceRegionException extends __BaseException {
+    readonly name: "S3LocationNotInServiceRegionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<S3LocationNotInServiceRegionException, __BaseException>);
+}
+
+export declare class TooManyApplicationVersionsException extends __BaseException {
+    readonly name: "TooManyApplicationVersionsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyApplicationVersionsException, __BaseException>);
+}
+export declare type ConfigurationDeploymentStatus = "deployed" | "failed" | "pending";
+
+export interface ConfigurationOptionSetting {
+    
+    ResourceName?: string;
+    
+    Namespace?: string;
+    
+    OptionName?: string;
+    
+    Value?: string;
+}
+export declare namespace ConfigurationOptionSetting {
+    
+    const filterSensitiveLog: (obj: ConfigurationOptionSetting) => any;
+}
+
+export interface ConfigurationSettingsDescription {
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    ApplicationName?: string;
+    
+    TemplateName?: string;
+    
+    Description?: string;
+    
+    EnvironmentName?: string;
+    
+    DeploymentStatus?: ConfigurationDeploymentStatus | string;
+    
+    DateCreated?: Date;
+    
+    DateUpdated?: Date;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+}
+export declare namespace ConfigurationSettingsDescription {
+    
+    const filterSensitiveLog: (obj: ConfigurationSettingsDescription) => any;
+}
+
+export interface SourceConfiguration {
+    
+    ApplicationName?: string;
+    
+    TemplateName?: string;
+}
+export declare namespace SourceConfiguration {
+    
+    const filterSensitiveLog: (obj: SourceConfiguration) => any;
+}
+
+export interface CreateConfigurationTemplateMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TemplateName: string | undefined;
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    SourceConfiguration?: SourceConfiguration;
+    
+    EnvironmentId?: string;
+    
+    Description?: string;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateConfigurationTemplateMessage {
+    
+    const filterSensitiveLog: (obj: CreateConfigurationTemplateMessage) => any;
+}
+
+export declare class TooManyBucketsException extends __BaseException {
+    readonly name: "TooManyBucketsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyBucketsException, __BaseException>);
+}
+
+export declare class TooManyConfigurationTemplatesException extends __BaseException {
+    readonly name: "TooManyConfigurationTemplatesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyConfigurationTemplatesException, __BaseException>);
+}
+
+export interface OptionSpecification {
+    
+    ResourceName?: string;
+    
+    Namespace?: string;
+    
+    OptionName?: string;
+}
+export declare namespace OptionSpecification {
+    
+    const filterSensitiveLog: (obj: OptionSpecification) => any;
+}
+
+export interface CreateEnvironmentMessage {
+    
+    ApplicationName: string | undefined;
+    
+    EnvironmentName?: string;
+    
+    GroupName?: string;
+    
+    Description?: string;
+    
+    CNAMEPrefix?: string;
+    
+    Tier?: EnvironmentTier;
+    
+    Tags?: Tag[];
+    
+    VersionLabel?: string;
+    
+    TemplateName?: string;
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+    
+    OptionsToRemove?: OptionSpecification[];
+    
+    OperationsRole?: string;
+}
+export declare namespace CreateEnvironmentMessage {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentMessage) => any;
+}
+
+export interface CreatePlatformVersionRequest {
+    
+    PlatformName: string | undefined;
+    
+    PlatformVersion: string | undefined;
+    
+    PlatformDefinitionBundle: S3Location | undefined;
+    
+    EnvironmentName?: string;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreatePlatformVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreatePlatformVersionRequest) => any;
+}
+
+export interface Builder {
+    
+    ARN?: string;
+}
+export declare namespace Builder {
+    
+    const filterSensitiveLog: (obj: Builder) => any;
+}
+export declare type PlatformStatus = "Creating" | "Deleted" | "Deleting" | "Failed" | "Ready";
+
+export interface PlatformSummary {
+    
+    PlatformArn?: string;
+    
+    PlatformOwner?: string;
+    
+    PlatformStatus?: PlatformStatus | string;
+    
+    PlatformCategory?: string;
+    
+    OperatingSystemName?: string;
+    
+    OperatingSystemVersion?: string;
+    
+    SupportedTierList?: string[];
+    
+    SupportedAddonList?: string[];
+    
+    PlatformLifecycleState?: string;
+    
+    PlatformVersion?: string;
+    
+    PlatformBranchName?: string;
+    
+    PlatformBranchLifecycleState?: string;
+}
+export declare namespace PlatformSummary {
+    
+    const filterSensitiveLog: (obj: PlatformSummary) => any;
+}
+export interface CreatePlatformVersionResult {
+    
+    PlatformSummary?: PlatformSummary;
+    
+    Builder?: Builder;
+}
+export declare namespace CreatePlatformVersionResult {
+    
+    const filterSensitiveLog: (obj: CreatePlatformVersionResult) => any;
+}
+
+export declare class TooManyPlatformsException extends __BaseException {
+    readonly name: "TooManyPlatformsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyPlatformsException, __BaseException>);
+}
+
+export interface CreateStorageLocationResultMessage {
+    
+    S3Bucket?: string;
+}
+export declare namespace CreateStorageLocationResultMessage {
+    
+    const filterSensitiveLog: (obj: CreateStorageLocationResultMessage) => any;
+}
+
+export declare class S3SubscriptionRequiredException extends __BaseException {
+    readonly name: "S3SubscriptionRequiredException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<S3SubscriptionRequiredException, __BaseException>);
+}
+
+export interface DeleteApplicationMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TerminateEnvByForce?: boolean;
+}
+export declare namespace DeleteApplicationMessage {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationMessage) => any;
+}
+
+export declare class OperationInProgressException extends __BaseException {
+    readonly name: "OperationInProgressException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OperationInProgressException, __BaseException>);
+}
+
+export interface DeleteApplicationVersionMessage {
+    
+    ApplicationName: string | undefined;
+    
+    VersionLabel: string | undefined;
+    
+    DeleteSourceBundle?: boolean;
+}
+export declare namespace DeleteApplicationVersionMessage {
+    
+    const filterSensitiveLog: (obj: DeleteApplicationVersionMessage) => any;
+}
+
+export declare class SourceBundleDeletionException extends __BaseException {
+    readonly name: "SourceBundleDeletionException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<SourceBundleDeletionException, __BaseException>);
+}
+
+export interface DeleteConfigurationTemplateMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TemplateName: string | undefined;
+}
+export declare namespace DeleteConfigurationTemplateMessage {
+    
+    const filterSensitiveLog: (obj: DeleteConfigurationTemplateMessage) => any;
+}
+
+export interface DeleteEnvironmentConfigurationMessage {
+    
+    ApplicationName: string | undefined;
+    
+    EnvironmentName: string | undefined;
+}
+export declare namespace DeleteEnvironmentConfigurationMessage {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentConfigurationMessage) => any;
+}
+export interface DeletePlatformVersionRequest {
+    
+    PlatformArn?: string;
+}
+export declare namespace DeletePlatformVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeletePlatformVersionRequest) => any;
+}
+export interface DeletePlatformVersionResult {
+    
+    PlatformSummary?: PlatformSummary;
+}
+export declare namespace DeletePlatformVersionResult {
+    
+    const filterSensitiveLog: (obj: DeletePlatformVersionResult) => any;
+}
+
+export declare class PlatformVersionStillReferencedException extends __BaseException {
+    readonly name: "PlatformVersionStillReferencedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<PlatformVersionStillReferencedException, __BaseException>);
+}
+
+export interface ResourceQuota {
+    
+    Maximum?: number;
+}
+export declare namespace ResourceQuota {
+    
+    const filterSensitiveLog: (obj: ResourceQuota) => any;
+}
+
+export interface ResourceQuotas {
+    
+    ApplicationQuota?: ResourceQuota;
+    
+    ApplicationVersionQuota?: ResourceQuota;
+    
+    EnvironmentQuota?: ResourceQuota;
+    
+    ConfigurationTemplateQuota?: ResourceQuota;
+    
+    CustomPlatformQuota?: ResourceQuota;
+}
+export declare namespace ResourceQuotas {
+    
+    const filterSensitiveLog: (obj: ResourceQuotas) => any;
+}
+export interface DescribeAccountAttributesResult {
+    
+    ResourceQuotas?: ResourceQuotas;
+}
+export declare namespace DescribeAccountAttributesResult {
+    
+    const filterSensitiveLog: (obj: DescribeAccountAttributesResult) => any;
+}
+
+export interface DescribeApplicationsMessage {
+    
+    ApplicationNames?: string[];
+}
+export declare namespace DescribeApplicationsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationsMessage) => any;
+}
+
+export interface DescribeApplicationVersionsMessage {
+    
+    ApplicationName?: string;
+    
+    VersionLabels?: string[];
+    
+    MaxRecords?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeApplicationVersionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeApplicationVersionsMessage) => any;
+}
+
+export interface OptionRestrictionRegex {
+    
+    Pattern?: string;
+    
+    Label?: string;
+}
+export declare namespace OptionRestrictionRegex {
+    
+    const filterSensitiveLog: (obj: OptionRestrictionRegex) => any;
+}
+export declare type ConfigurationOptionValueType = "List" | "Scalar";
+
+export interface ConfigurationOptionDescription {
+    
+    Namespace?: string;
+    
+    Name?: string;
+    
+    DefaultValue?: string;
+    
+    ChangeSeverity?: string;
+    
+    UserDefined?: boolean;
+    
+    ValueType?: ConfigurationOptionValueType | string;
+    
+    ValueOptions?: string[];
+    
+    MinValue?: number;
+    
+    MaxValue?: number;
+    
+    MaxLength?: number;
+    
+    Regex?: OptionRestrictionRegex;
+}
+export declare namespace ConfigurationOptionDescription {
+    
+    const filterSensitiveLog: (obj: ConfigurationOptionDescription) => any;
+}
+
+export interface ConfigurationOptionsDescription {
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    Options?: ConfigurationOptionDescription[];
+}
+export declare namespace ConfigurationOptionsDescription {
+    
+    const filterSensitiveLog: (obj: ConfigurationOptionsDescription) => any;
+}
+
+export interface DescribeConfigurationOptionsMessage {
+    
+    ApplicationName?: string;
+    
+    TemplateName?: string;
+    
+    EnvironmentName?: string;
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    Options?: OptionSpecification[];
+}
+export declare namespace DescribeConfigurationOptionsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationOptionsMessage) => any;
+}
+
+export interface ConfigurationSettingsDescriptions {
+    
+    ConfigurationSettings?: ConfigurationSettingsDescription[];
+}
+export declare namespace ConfigurationSettingsDescriptions {
+    
+    const filterSensitiveLog: (obj: ConfigurationSettingsDescriptions) => any;
+}
+
+export interface DescribeConfigurationSettingsMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TemplateName?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace DescribeConfigurationSettingsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeConfigurationSettingsMessage) => any;
+}
+export declare enum EnvironmentHealthAttribute {
+    All = "All",
+    ApplicationMetrics = "ApplicationMetrics",
+    Causes = "Causes",
+    Color = "Color",
+    HealthStatus = "HealthStatus",
+    InstancesHealth = "InstancesHealth",
+    RefreshedAt = "RefreshedAt",
+    Status = "Status"
+}
+
+export interface DescribeEnvironmentHealthRequest {
+    
+    EnvironmentName?: string;
+    
+    EnvironmentId?: string;
+    
+    AttributeNames?: (EnvironmentHealthAttribute | string)[];
+}
+export declare namespace DescribeEnvironmentHealthRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentHealthRequest) => any;
+}
+
+export interface InstanceHealthSummary {
+    
+    NoData?: number;
+    
+    Unknown?: number;
+    
+    Pending?: number;
+    
+    Ok?: number;
+    
+    Info?: number;
+    
+    Warning?: number;
+    
+    Degraded?: number;
+    
+    Severe?: number;
+}
+export declare namespace InstanceHealthSummary {
+    
+    const filterSensitiveLog: (obj: InstanceHealthSummary) => any;
+}
+
+export interface DescribeEnvironmentHealthResult {
+    
+    EnvironmentName?: string;
+    
+    HealthStatus?: string;
+    
+    Status?: EnvironmentHealth | string;
+    
+    Color?: string;
+    
+    Causes?: string[];
+    
+    ApplicationMetrics?: ApplicationMetrics;
+    
+    InstancesHealth?: InstanceHealthSummary;
+    
+    RefreshedAt?: Date;
+}
+export declare namespace DescribeEnvironmentHealthResult {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentHealthResult) => any;
+}
+
+export declare class InvalidRequestException extends __BaseException {
+    readonly name: "InvalidRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidRequestException, __BaseException>);
+}
+
+export interface DescribeEnvironmentManagedActionHistoryRequest {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    NextToken?: string;
+    
+    MaxItems?: number;
+}
+export declare namespace DescribeEnvironmentManagedActionHistoryRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentManagedActionHistoryRequest) => any;
+}
+export declare type FailureType = "CancellationFailed" | "InternalFailure" | "InvalidEnvironmentState" | "PermissionsError" | "RollbackFailed" | "RollbackSuccessful" | "UpdateCancelled";
+
+export interface ManagedActionHistoryItem {
+    
+    ActionId?: string;
+    
+    ActionType?: ActionType | string;
+    
+    ActionDescription?: string;
+    
+    FailureType?: FailureType | string;
+    
+    Status?: ActionHistoryStatus | string;
+    
+    FailureDescription?: string;
+    
+    ExecutedTime?: Date;
+    
+    FinishedTime?: Date;
+}
+export declare namespace ManagedActionHistoryItem {
+    
+    const filterSensitiveLog: (obj: ManagedActionHistoryItem) => any;
+}
+
+export interface DescribeEnvironmentManagedActionHistoryResult {
+    
+    ManagedActionHistoryItems?: ManagedActionHistoryItem[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEnvironmentManagedActionHistoryResult {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentManagedActionHistoryResult) => any;
+}
+
+export interface DescribeEnvironmentManagedActionsRequest {
+    
+    EnvironmentName?: string;
+    
+    EnvironmentId?: string;
+    
+    Status?: ActionStatus | string;
+}
+export declare namespace DescribeEnvironmentManagedActionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentManagedActionsRequest) => any;
+}
+
+export interface ManagedAction {
+    
+    ActionId?: string;
+    
+    ActionDescription?: string;
+    
+    ActionType?: ActionType | string;
+    
+    Status?: ActionStatus | string;
+    
+    WindowStartTime?: Date;
+}
+export declare namespace ManagedAction {
+    
+    const filterSensitiveLog: (obj: ManagedAction) => any;
+}
+
+export interface DescribeEnvironmentManagedActionsResult {
+    
+    ManagedActions?: ManagedAction[];
+}
+export declare namespace DescribeEnvironmentManagedActionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentManagedActionsResult) => any;
+}
+
+export interface DescribeEnvironmentResourcesMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace DescribeEnvironmentResourcesMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentResourcesMessage) => any;
+}
+
+export interface Instance {
+    
+    Id?: string;
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+
+export interface LaunchConfiguration {
+    
+    Name?: string;
+}
+export declare namespace LaunchConfiguration {
+    
+    const filterSensitiveLog: (obj: LaunchConfiguration) => any;
+}
+
+export interface LaunchTemplate {
+    
+    Id?: string;
+}
+export declare namespace LaunchTemplate {
+    
+    const filterSensitiveLog: (obj: LaunchTemplate) => any;
+}
+
+export interface LoadBalancer {
+    
+    Name?: string;
+}
+export declare namespace LoadBalancer {
+    
+    const filterSensitiveLog: (obj: LoadBalancer) => any;
+}
+
+export interface Queue {
+    
+    Name?: string;
+    
+    URL?: string;
+}
+export declare namespace Queue {
+    
+    const filterSensitiveLog: (obj: Queue) => any;
+}
+
+export interface Trigger {
+    
+    Name?: string;
+}
+export declare namespace Trigger {
+    
+    const filterSensitiveLog: (obj: Trigger) => any;
+}
+
+export interface EnvironmentResourceDescription {
+    
+    EnvironmentName?: string;
+    
+    AutoScalingGroups?: AutoScalingGroup[];
+    
+    Instances?: Instance[];
+    
+    LaunchConfigurations?: LaunchConfiguration[];
+    
+    LaunchTemplates?: LaunchTemplate[];
+    
+    LoadBalancers?: LoadBalancer[];
+    
+    Triggers?: Trigger[];
+    
+    Queues?: Queue[];
+}
+export declare namespace EnvironmentResourceDescription {
+    
+    const filterSensitiveLog: (obj: EnvironmentResourceDescription) => any;
+}
+
+export interface EnvironmentResourceDescriptionsMessage {
+    
+    EnvironmentResources?: EnvironmentResourceDescription;
+}
+export declare namespace EnvironmentResourceDescriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EnvironmentResourceDescriptionsMessage) => any;
+}
+
+export interface DescribeEnvironmentsMessage {
+    
+    ApplicationName?: string;
+    
+    VersionLabel?: string;
+    
+    EnvironmentIds?: string[];
+    
+    EnvironmentNames?: string[];
+    
+    IncludeDeleted?: boolean;
+    
+    IncludedDeletedBackTo?: Date;
+    
+    MaxRecords?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEnvironmentsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEnvironmentsMessage) => any;
+}
+export declare type EventSeverity = "DEBUG" | "ERROR" | "FATAL" | "INFO" | "TRACE" | "WARN";
+
+export interface DescribeEventsMessage {
+    
+    ApplicationName?: string;
+    
+    VersionLabel?: string;
+    
+    TemplateName?: string;
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    PlatformArn?: string;
+    
+    RequestId?: string;
+    
+    Severity?: EventSeverity | string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    MaxRecords?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeEventsMessage {
+    
+    const filterSensitiveLog: (obj: DescribeEventsMessage) => any;
+}
+
+export interface EventDescription {
+    
+    EventDate?: Date;
+    
+    Message?: string;
+    
+    ApplicationName?: string;
+    
+    VersionLabel?: string;
+    
+    TemplateName?: string;
+    
+    EnvironmentName?: string;
+    
+    PlatformArn?: string;
+    
+    RequestId?: string;
+    
+    Severity?: EventSeverity | string;
+}
+export declare namespace EventDescription {
+    
+    const filterSensitiveLog: (obj: EventDescription) => any;
+}
+
+export interface EventDescriptionsMessage {
+    
+    Events?: EventDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace EventDescriptionsMessage {
+    
+    const filterSensitiveLog: (obj: EventDescriptionsMessage) => any;
+}
+export declare enum InstancesHealthAttribute {
+    All = "All",
+    ApplicationMetrics = "ApplicationMetrics",
+    AvailabilityZone = "AvailabilityZone",
+    Causes = "Causes",
+    Color = "Color",
+    Deployment = "Deployment",
+    HealthStatus = "HealthStatus",
+    InstanceType = "InstanceType",
+    LaunchedAt = "LaunchedAt",
+    RefreshedAt = "RefreshedAt",
+    System = "System"
+}
+
+export interface DescribeInstancesHealthRequest {
+    
+    EnvironmentName?: string;
+    
+    EnvironmentId?: string;
+    
+    AttributeNames?: (InstancesHealthAttribute | string)[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancesHealthRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInstancesHealthRequest) => any;
+}
+
+export interface Deployment {
+    
+    VersionLabel?: string;
+    
+    DeploymentId?: number;
+    
+    Status?: string;
+    
+    DeploymentTime?: Date;
+}
+export declare namespace Deployment {
+    
+    const filterSensitiveLog: (obj: Deployment) => any;
+}
+
+export interface CPUUtilization {
+    
+    User?: number;
+    
+    Nice?: number;
+    
+    System?: number;
+    
+    Idle?: number;
+    
+    IOWait?: number;
+    
+    IRQ?: number;
+    
+    SoftIRQ?: number;
+    
+    Privileged?: number;
+}
+export declare namespace CPUUtilization {
+    
+    const filterSensitiveLog: (obj: CPUUtilization) => any;
+}
+
+export interface SystemStatus {
+    
+    CPUUtilization?: CPUUtilization;
+    
+    LoadAverage?: number[];
+}
+export declare namespace SystemStatus {
+    
+    const filterSensitiveLog: (obj: SystemStatus) => any;
+}
+
+export interface SingleInstanceHealth {
+    
+    InstanceId?: string;
+    
+    HealthStatus?: string;
+    
+    Color?: string;
+    
+    Causes?: string[];
+    
+    LaunchedAt?: Date;
+    
+    ApplicationMetrics?: ApplicationMetrics;
+    
+    System?: SystemStatus;
+    
+    Deployment?: Deployment;
+    
+    AvailabilityZone?: string;
+    
+    InstanceType?: string;
+}
+export declare namespace SingleInstanceHealth {
+    
+    const filterSensitiveLog: (obj: SingleInstanceHealth) => any;
+}
+
+export interface DescribeInstancesHealthResult {
+    
+    InstanceHealthList?: SingleInstanceHealth[];
+    
+    RefreshedAt?: Date;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancesHealthResult {
+    
+    const filterSensitiveLog: (obj: DescribeInstancesHealthResult) => any;
+}
+export interface DescribePlatformVersionRequest {
+    
+    PlatformArn?: string;
+}
+export declare namespace DescribePlatformVersionRequest {
+    
+    const filterSensitiveLog: (obj: DescribePlatformVersionRequest) => any;
+}
+
+export interface CustomAmi {
+    
+    VirtualizationType?: string;
+    
+    ImageId?: string;
+}
+export declare namespace CustomAmi {
+    
+    const filterSensitiveLog: (obj: CustomAmi) => any;
+}
+
+export interface PlatformFramework {
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace PlatformFramework {
+    
+    const filterSensitiveLog: (obj: PlatformFramework) => any;
+}
+
+export interface PlatformProgrammingLanguage {
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace PlatformProgrammingLanguage {
+    
+    const filterSensitiveLog: (obj: PlatformProgrammingLanguage) => any;
+}
+
+export interface PlatformDescription {
+    
+    PlatformArn?: string;
+    
+    PlatformOwner?: string;
+    
+    PlatformName?: string;
+    
+    PlatformVersion?: string;
+    
+    SolutionStackName?: string;
+    
+    PlatformStatus?: PlatformStatus | string;
+    
+    DateCreated?: Date;
+    
+    DateUpdated?: Date;
+    
+    PlatformCategory?: string;
+    
+    Description?: string;
+    
+    Maintainer?: string;
+    
+    OperatingSystemName?: string;
+    
+    OperatingSystemVersion?: string;
+    
+    ProgrammingLanguages?: PlatformProgrammingLanguage[];
+    
+    Frameworks?: PlatformFramework[];
+    
+    CustomAmiList?: CustomAmi[];
+    
+    SupportedTierList?: string[];
+    
+    SupportedAddonList?: string[];
+    
+    PlatformLifecycleState?: string;
+    
+    PlatformBranchName?: string;
+    
+    PlatformBranchLifecycleState?: string;
+}
+export declare namespace PlatformDescription {
+    
+    const filterSensitiveLog: (obj: PlatformDescription) => any;
+}
+export interface DescribePlatformVersionResult {
+    
+    PlatformDescription?: PlatformDescription;
+}
+export declare namespace DescribePlatformVersionResult {
+    
+    const filterSensitiveLog: (obj: DescribePlatformVersionResult) => any;
+}
+
+export interface DisassociateEnvironmentOperationsRoleMessage {
+    
+    EnvironmentName: string | undefined;
+}
+export declare namespace DisassociateEnvironmentOperationsRoleMessage {
+    
+    const filterSensitiveLog: (obj: DisassociateEnvironmentOperationsRoleMessage) => any;
+}
+
+export interface ListAvailableSolutionStacksResultMessage {
+    
+    SolutionStacks?: string[];
+    
+    SolutionStackDetails?: SolutionStackDescription[];
+}
+export declare namespace ListAvailableSolutionStacksResultMessage {
+    
+    const filterSensitiveLog: (obj: ListAvailableSolutionStacksResultMessage) => any;
+}
+
+export interface SearchFilter {
+    
+    Attribute?: string;
+    
+    Operator?: string;
+    
+    Values?: string[];
+}
+export declare namespace SearchFilter {
+    
+    const filterSensitiveLog: (obj: SearchFilter) => any;
+}
+export interface ListPlatformBranchesRequest {
+    
+    Filters?: SearchFilter[];
+    
+    MaxRecords?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformBranchesRequest {
+    
+    const filterSensitiveLog: (obj: ListPlatformBranchesRequest) => any;
+}
+
+export interface PlatformBranchSummary {
+    
+    PlatformName?: string;
+    
+    BranchName?: string;
+    
+    LifecycleState?: string;
+    
+    BranchOrder?: number;
+    
+    SupportedTierList?: string[];
+}
+export declare namespace PlatformBranchSummary {
+    
+    const filterSensitiveLog: (obj: PlatformBranchSummary) => any;
+}
+export interface ListPlatformBranchesResult {
+    
+    PlatformBranchSummaryList?: PlatformBranchSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformBranchesResult {
+    
+    const filterSensitiveLog: (obj: ListPlatformBranchesResult) => any;
+}
+
+export interface PlatformFilter {
+    
+    Type?: string;
+    
+    Operator?: string;
+    
+    Values?: string[];
+}
+export declare namespace PlatformFilter {
+    
+    const filterSensitiveLog: (obj: PlatformFilter) => any;
+}
+export interface ListPlatformVersionsRequest {
+    
+    Filters?: PlatformFilter[];
+    
+    MaxRecords?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformVersionsRequest {
+    
+    const filterSensitiveLog: (obj: ListPlatformVersionsRequest) => any;
+}
+export interface ListPlatformVersionsResult {
+    
+    PlatformSummaryList?: PlatformSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPlatformVersionsResult {
+    
+    const filterSensitiveLog: (obj: ListPlatformVersionsResult) => any;
+}
+export interface ListTagsForResourceMessage {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceMessage {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceMessage) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface ResourceTagsDescriptionMessage {
+    
+    ResourceArn?: string;
+    
+    ResourceTags?: Tag[];
+}
+export declare namespace ResourceTagsDescriptionMessage {
+    
+    const filterSensitiveLog: (obj: ResourceTagsDescriptionMessage) => any;
+}
+
+export declare class ResourceTypeNotSupportedException extends __BaseException {
+    readonly name: "ResourceTypeNotSupportedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceTypeNotSupportedException, __BaseException>);
+}
+
+export interface RebuildEnvironmentMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace RebuildEnvironmentMessage {
+    
+    const filterSensitiveLog: (obj: RebuildEnvironmentMessage) => any;
+}
+export declare type EnvironmentInfoType = "bundle" | "tail";
+
+export interface RequestEnvironmentInfoMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    InfoType: EnvironmentInfoType | string | undefined;
+}
+export declare namespace RequestEnvironmentInfoMessage {
+    
+    const filterSensitiveLog: (obj: RequestEnvironmentInfoMessage) => any;
+}
+
+export interface RestartAppServerMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+}
+export declare namespace RestartAppServerMessage {
+    
+    const filterSensitiveLog: (obj: RestartAppServerMessage) => any;
+}
+
+export interface RetrieveEnvironmentInfoMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    InfoType: EnvironmentInfoType | string | undefined;
+}
+export declare namespace RetrieveEnvironmentInfoMessage {
+    
+    const filterSensitiveLog: (obj: RetrieveEnvironmentInfoMessage) => any;
+}
+
+export interface EnvironmentInfoDescription {
+    
+    InfoType?: EnvironmentInfoType | string;
+    
+    Ec2InstanceId?: string;
+    
+    SampleTimestamp?: Date;
+    
+    Message?: string;
+}
+export declare namespace EnvironmentInfoDescription {
+    
+    const filterSensitiveLog: (obj: EnvironmentInfoDescription) => any;
+}
+
+export interface RetrieveEnvironmentInfoResultMessage {
+    
+    EnvironmentInfo?: EnvironmentInfoDescription[];
+}
+export declare namespace RetrieveEnvironmentInfoResultMessage {
+    
+    const filterSensitiveLog: (obj: RetrieveEnvironmentInfoResultMessage) => any;
+}
+
+export interface SwapEnvironmentCNAMEsMessage {
+    
+    SourceEnvironmentId?: string;
+    
+    SourceEnvironmentName?: string;
+    
+    DestinationEnvironmentId?: string;
+    
+    DestinationEnvironmentName?: string;
+}
+export declare namespace SwapEnvironmentCNAMEsMessage {
+    
+    const filterSensitiveLog: (obj: SwapEnvironmentCNAMEsMessage) => any;
+}
+
+export interface TerminateEnvironmentMessage {
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    TerminateResources?: boolean;
+    
+    ForceTerminate?: boolean;
+}
+export declare namespace TerminateEnvironmentMessage {
+    
+    const filterSensitiveLog: (obj: TerminateEnvironmentMessage) => any;
+}
+
+export interface UpdateApplicationMessage {
+    
+    ApplicationName: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdateApplicationMessage {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationMessage) => any;
+}
+export interface UpdateApplicationResourceLifecycleMessage {
+    
+    ApplicationName: string | undefined;
+    
+    ResourceLifecycleConfig: ApplicationResourceLifecycleConfig | undefined;
+}
+export declare namespace UpdateApplicationResourceLifecycleMessage {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationResourceLifecycleMessage) => any;
+}
+
+export interface UpdateApplicationVersionMessage {
+    
+    ApplicationName: string | undefined;
+    
+    VersionLabel: string | undefined;
+    
+    Description?: string;
+}
+export declare namespace UpdateApplicationVersionMessage {
+    
+    const filterSensitiveLog: (obj: UpdateApplicationVersionMessage) => any;
+}
+
+export interface UpdateConfigurationTemplateMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TemplateName: string | undefined;
+    
+    Description?: string;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+    
+    OptionsToRemove?: OptionSpecification[];
+}
+export declare namespace UpdateConfigurationTemplateMessage {
+    
+    const filterSensitiveLog: (obj: UpdateConfigurationTemplateMessage) => any;
+}
+
+export interface UpdateEnvironmentMessage {
+    
+    ApplicationName?: string;
+    
+    EnvironmentId?: string;
+    
+    EnvironmentName?: string;
+    
+    GroupName?: string;
+    
+    Description?: string;
+    
+    Tier?: EnvironmentTier;
+    
+    VersionLabel?: string;
+    
+    TemplateName?: string;
+    
+    SolutionStackName?: string;
+    
+    PlatformArn?: string;
+    
+    OptionSettings?: ConfigurationOptionSetting[];
+    
+    OptionsToRemove?: OptionSpecification[];
+}
+export declare namespace UpdateEnvironmentMessage {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentMessage) => any;
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+export interface UpdateTagsForResourceMessage {
+    
+    ResourceArn: string | undefined;
+    
+    TagsToAdd?: Tag[];
+    
+    TagsToRemove?: string[];
+}
+export declare namespace UpdateTagsForResourceMessage {
+    
+    const filterSensitiveLog: (obj: UpdateTagsForResourceMessage) => any;
+}
+export declare type ValidationSeverity = "error" | "warning";
+
+export interface ValidationMessage {
+    
+    Message?: string;
+    
+    Severity?: ValidationSeverity | string;
+    
+    Namespace?: string;
+    
+    OptionName?: string;
+}
+export declare namespace ValidationMessage {
+    
+    const filterSensitiveLog: (obj: ValidationMessage) => any;
+}
+
+export interface ConfigurationSettingsValidationMessages {
+    
+    Messages?: ValidationMessage[];
+}
+export declare namespace ConfigurationSettingsValidationMessages {
+    
+    const filterSensitiveLog: (obj: ConfigurationSettingsValidationMessages) => any;
+}
+
+export interface ValidateConfigurationSettingsMessage {
+    
+    ApplicationName: string | undefined;
+    
+    TemplateName?: string;
+    
+    EnvironmentName?: string;
+    
+    OptionSettings: ConfigurationOptionSetting[] | undefined;
+}
+export declare namespace ValidateConfigurationSettingsMessage {
+    
+    const filterSensitiveLog: (obj: ValidateConfigurationSettingsMessage) => any;
+}