@aws-sdk/client-elastic-beanstalk 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/AbortEnvironmentUpdateCommand.d.ts

@@ -1,36 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { AbortEnvironmentUpdateMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface AbortEnvironmentUpdateCommandInput extends AbortEnvironmentUpdateMessage {
-}
-export interface AbortEnvironmentUpdateCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Cancels in-progress environment configuration update or application version
- *       deployment.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, AbortEnvironmentUpdateCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, AbortEnvironmentUpdateCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new AbortEnvironmentUpdateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AbortEnvironmentUpdateCommandInput} for command's `input` shape.
- * @see {@link AbortEnvironmentUpdateCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class AbortEnvironmentUpdateCommand extends $Command<AbortEnvironmentUpdateCommandInput, AbortEnvironmentUpdateCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: AbortEnvironmentUpdateCommandInput;
-    constructor(input: AbortEnvironmentUpdateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AbortEnvironmentUpdateCommandInput, AbortEnvironmentUpdateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ApplyEnvironmentManagedActionCommand.d.ts

@@ -1,37 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ApplyEnvironmentManagedActionRequest, ApplyEnvironmentManagedActionResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ApplyEnvironmentManagedActionCommandInput extends ApplyEnvironmentManagedActionRequest {
-}
-export interface ApplyEnvironmentManagedActionCommandOutput extends ApplyEnvironmentManagedActionResult, __MetadataBearer {
-}
-/**
- * <p>Applies a scheduled managed action immediately. A managed action can be applied only if
- *       its status is <code>Scheduled</code>. Get the status and action ID of a managed action with
- *         <a>DescribeEnvironmentManagedActions</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, ApplyEnvironmentManagedActionCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, ApplyEnvironmentManagedActionCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new ApplyEnvironmentManagedActionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ApplyEnvironmentManagedActionCommandInput} for command's `input` shape.
- * @see {@link ApplyEnvironmentManagedActionCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ApplyEnvironmentManagedActionCommand extends $Command<ApplyEnvironmentManagedActionCommandInput, ApplyEnvironmentManagedActionCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: ApplyEnvironmentManagedActionCommandInput;
-    constructor(input: ApplyEnvironmentManagedActionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplyEnvironmentManagedActionCommandInput, ApplyEnvironmentManagedActionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/AssociateEnvironmentOperationsRoleCommand.d.ts

@@ -1,38 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { AssociateEnvironmentOperationsRoleMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface AssociateEnvironmentOperationsRoleCommandInput extends AssociateEnvironmentOperationsRoleMessage {
-}
-export interface AssociateEnvironmentOperationsRoleCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Add or change the operations role used by an environment. After this call is made, Elastic Beanstalk
- *       uses the associated operations role for permissions to downstream services during subsequent
- *       calls acting on this environment. For more information, see <a href="https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/iam-operationsrole.html">Operations roles</a> in the
- *         <i>AWS Elastic Beanstalk Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, AssociateEnvironmentOperationsRoleCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, AssociateEnvironmentOperationsRoleCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new AssociateEnvironmentOperationsRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociateEnvironmentOperationsRoleCommandInput} for command's `input` shape.
- * @see {@link AssociateEnvironmentOperationsRoleCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class AssociateEnvironmentOperationsRoleCommand extends $Command<AssociateEnvironmentOperationsRoleCommandInput, AssociateEnvironmentOperationsRoleCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: AssociateEnvironmentOperationsRoleCommandInput;
-    constructor(input: AssociateEnvironmentOperationsRoleCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateEnvironmentOperationsRoleCommandInput, AssociateEnvironmentOperationsRoleCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ComposeEnvironmentsCommand.d.ts

@@ -1,40 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ComposeEnvironmentsMessage, EnvironmentDescriptionsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ComposeEnvironmentsCommandInput extends ComposeEnvironmentsMessage {
-}
-export interface ComposeEnvironmentsCommandOutput extends EnvironmentDescriptionsMessage, __MetadataBearer {
-}
-/**
- * <p>Create or update a group of environments that each run a separate component of a single
- *       application. Takes a list of version labels that specify application source bundles for each
- *       of the environments to create or update. The name of each environment and other required
- *       information must be included in the source bundles in an environment manifest named
- *       <code>env.yaml</code>. See <a href="https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-mgmt-compose.html">Compose Environments</a>
- *       for details.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, ComposeEnvironmentsCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, ComposeEnvironmentsCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new ComposeEnvironmentsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ComposeEnvironmentsCommandInput} for command's `input` shape.
- * @see {@link ComposeEnvironmentsCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ComposeEnvironmentsCommand extends $Command<ComposeEnvironmentsCommandInput, ComposeEnvironmentsCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: ComposeEnvironmentsCommandInput;
-    constructor(input: ComposeEnvironmentsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ComposeEnvironmentsCommandInput, ComposeEnvironmentsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateApplicationCommand.d.ts

@@ -1,36 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ApplicationDescriptionMessage, CreateApplicationMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateApplicationCommandInput extends CreateApplicationMessage {
-}
-export interface CreateApplicationCommandOutput extends ApplicationDescriptionMessage, __MetadataBearer {
-}
-/**
- * <p>Creates an application that has one configuration template named <code>default</code>
- *       and no application versions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, CreateApplicationCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, CreateApplicationCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new CreateApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateApplicationCommandInput} for command's `input` shape.
- * @see {@link CreateApplicationCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateApplicationCommand extends $Command<CreateApplicationCommandInput, CreateApplicationCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: CreateApplicationCommandInput;
-    constructor(input: CreateApplicationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationCommandInput, CreateApplicationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateApplicationVersionCommand.d.ts

@@ -1,51 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ApplicationVersionDescriptionMessage, CreateApplicationVersionMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateApplicationVersionCommandInput extends CreateApplicationVersionMessage {
-}
-export interface CreateApplicationVersionCommandOutput extends ApplicationVersionDescriptionMessage, __MetadataBearer {
-}
-/**
- * <p>Creates an application version for the specified application. You can create an
- *       application version from a source bundle in Amazon S3, a commit in AWS CodeCommit, or the
- *       output of an AWS CodeBuild build as follows:</p>
- *          <p>Specify a commit in an AWS CodeCommit repository with
- *         <code>SourceBuildInformation</code>.</p>
- *          <p>Specify a build in an AWS CodeBuild with <code>SourceBuildInformation</code> and
- *         <code>BuildConfiguration</code>.</p>
- *          <p>Specify a source bundle in S3 with <code>SourceBundle</code>
- *          </p>
- *          <p>Omit both <code>SourceBuildInformation</code> and <code>SourceBundle</code> to use the
- *       default sample application.</p>
- *          <note>
- *             <p>After you create an application version with a specified Amazon S3 bucket and key
- *         location, you can't change that Amazon S3 location. If you change the Amazon S3 location,
- *         you receive an exception when you attempt to launch an environment from the application
- *         version.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, CreateApplicationVersionCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, CreateApplicationVersionCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new CreateApplicationVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateApplicationVersionCommandInput} for command's `input` shape.
- * @see {@link CreateApplicationVersionCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateApplicationVersionCommand extends $Command<CreateApplicationVersionCommandInput, CreateApplicationVersionCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: CreateApplicationVersionCommandInput;
-    constructor(input: CreateApplicationVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationVersionCommandInput, CreateApplicationVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateConfigurationTemplateCommand.d.ts

@@ -1,58 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ConfigurationSettingsDescription, CreateConfigurationTemplateMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateConfigurationTemplateCommandInput extends CreateConfigurationTemplateMessage {
-}
-export interface CreateConfigurationTemplateCommandOutput extends ConfigurationSettingsDescription, __MetadataBearer {
-}
-/**
- * <p>Creates an AWS Elastic Beanstalk configuration template, associated with a specific Elastic Beanstalk
- *       application. You define application configuration settings in a configuration template. You
- *       can then use the configuration template to deploy different versions of the application with
- *       the same configuration settings.</p>
- *          <p>Templates aren't associated with any environment. The <code>EnvironmentName</code>
- *       response element is always <code>null</code>.</p>
- *          <p>Related Topics</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>DescribeConfigurationOptions</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeConfigurationSettings</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>ListAvailableSolutionStacks</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, CreateConfigurationTemplateCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, CreateConfigurationTemplateCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new CreateConfigurationTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateConfigurationTemplateCommandInput} for command's `input` shape.
- * @see {@link CreateConfigurationTemplateCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateConfigurationTemplateCommand extends $Command<CreateConfigurationTemplateCommandInput, CreateConfigurationTemplateCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: CreateConfigurationTemplateCommandInput;
-    constructor(input: CreateConfigurationTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConfigurationTemplateCommandInput, CreateConfigurationTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateEnvironmentCommand.d.ts

@@ -1,36 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { CreateEnvironmentMessage, EnvironmentDescription } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateEnvironmentCommandInput extends CreateEnvironmentMessage {
-}
-export interface CreateEnvironmentCommandOutput extends EnvironmentDescription, __MetadataBearer {
-}
-/**
- * <p>Launches an AWS Elastic Beanstalk environment for the specified application using the specified
- *       configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, CreateEnvironmentCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, CreateEnvironmentCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new CreateEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEnvironmentCommandInput} for command's `input` shape.
- * @see {@link CreateEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateEnvironmentCommand extends $Command<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: CreateEnvironmentCommandInput;
-    constructor(input: CreateEnvironmentCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateStorageLocationCommand.d.ts

@@ -1,39 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { CreateStorageLocationResultMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateStorageLocationCommandInput {
-}
-export interface CreateStorageLocationCommandOutput extends CreateStorageLocationResultMessage, __MetadataBearer {
-}
-/**
- * <p>Creates a bucket in Amazon S3 to store application versions, logs, and other files used
- *       by Elastic Beanstalk environments. The Elastic Beanstalk console and EB CLI call this API the
- *       first time you create an environment in a region. If the storage location already exists,
- *         <code>CreateStorageLocation</code> still returns the bucket name but does not create a new
- *       bucket.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, CreateStorageLocationCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, CreateStorageLocationCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new CreateStorageLocationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateStorageLocationCommandInput} for command's `input` shape.
- * @see {@link CreateStorageLocationCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateStorageLocationCommand extends $Command<CreateStorageLocationCommandInput, CreateStorageLocationCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: CreateStorageLocationCommandInput;
-    constructor(input: CreateStorageLocationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStorageLocationCommandInput, CreateStorageLocationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteApplicationCommand.d.ts

@@ -1,40 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { DeleteApplicationMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteApplicationCommandInput extends DeleteApplicationMessage {
-}
-export interface DeleteApplicationCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified application along with all associated versions and
- *       configurations. The application versions will not be deleted from your Amazon S3
- *       bucket.</p>
- *          <note>
- *             <p>You cannot delete an application that has a running environment.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DeleteApplicationCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DeleteApplicationCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DeleteApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteApplicationCommand extends $Command<DeleteApplicationCommandInput, DeleteApplicationCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DeleteApplicationCommandInput;
-    constructor(input: DeleteApplicationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationCommandInput, DeleteApplicationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteApplicationVersionCommand.d.ts

@@ -1,39 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { DeleteApplicationVersionMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteApplicationVersionCommandInput extends DeleteApplicationVersionMessage {
-}
-export interface DeleteApplicationVersionCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified version from the specified application.</p>
- *          <note>
- *             <p>You cannot delete an application version that is associated with a running
- *         environment.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DeleteApplicationVersionCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DeleteApplicationVersionCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DeleteApplicationVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationVersionCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteApplicationVersionCommand extends $Command<DeleteApplicationVersionCommandInput, DeleteApplicationVersionCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DeleteApplicationVersionCommandInput;
-    constructor(input: DeleteApplicationVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationVersionCommandInput, DeleteApplicationVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteConfigurationTemplateCommand.d.ts

@@ -1,40 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { DeleteConfigurationTemplateMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteConfigurationTemplateCommandInput extends DeleteConfigurationTemplateMessage {
-}
-export interface DeleteConfigurationTemplateCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the specified configuration template.</p>
- *          <note>
- *             <p>When you launch an environment using a configuration template, the environment gets a
- *         copy of the template. You can delete or modify the environment's copy of the template
- *         without affecting the running environment.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DeleteConfigurationTemplateCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DeleteConfigurationTemplateCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DeleteConfigurationTemplateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteConfigurationTemplateCommandInput} for command's `input` shape.
- * @see {@link DeleteConfigurationTemplateCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteConfigurationTemplateCommand extends $Command<DeleteConfigurationTemplateCommandInput, DeleteConfigurationTemplateCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DeleteConfigurationTemplateCommandInput;
-    constructor(input: DeleteConfigurationTemplateCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfigurationTemplateCommandInput, DeleteConfigurationTemplateCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteEnvironmentConfigurationCommand.d.ts

@@ -1,40 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { DeleteEnvironmentConfigurationMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEnvironmentConfigurationCommandInput extends DeleteEnvironmentConfigurationMessage {
-}
-export interface DeleteEnvironmentConfigurationCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes the draft configuration associated with the running environment.</p>
- *          <p>Updating a running environment with any configuration changes creates a draft
- *       configuration set. You can get the draft configuration using <a>DescribeConfigurationSettings</a> while the update is in progress or if the update
- *       fails. The <code>DeploymentStatus</code> for the draft configuration indicates whether the
- *       deployment is in process or has failed. The draft configuration remains in existence until it
- *       is deleted with this action.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DeleteEnvironmentConfigurationCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DeleteEnvironmentConfigurationCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DeleteEnvironmentConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentConfigurationCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEnvironmentConfigurationCommand extends $Command<DeleteEnvironmentConfigurationCommandInput, DeleteEnvironmentConfigurationCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DeleteEnvironmentConfigurationCommandInput;
-    constructor(input: DeleteEnvironmentConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentConfigurationCommandInput, DeleteEnvironmentConfigurationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeAccountAttributesCommand.d.ts

@@ -1,37 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { DescribeAccountAttributesResult } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeAccountAttributesCommandInput {
-}
-export interface DescribeAccountAttributesCommandOutput extends DescribeAccountAttributesResult, __MetadataBearer {
-}
-/**
- * <p>Returns attributes related to AWS Elastic Beanstalk that are associated with the calling AWS
- *       account.</p>
- *          <p>The result currently has one set of attributes—resource quotas.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DescribeAccountAttributesCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DescribeAccountAttributesCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DescribeAccountAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeAccountAttributesCommandInput} for command's `input` shape.
- * @see {@link DescribeAccountAttributesCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeAccountAttributesCommand extends $Command<DescribeAccountAttributesCommandInput, DescribeAccountAttributesCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DescribeAccountAttributesCommandInput;
-    constructor(input: DescribeAccountAttributesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeAccountAttributesCommandInput, DescribeAccountAttributesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeConfigurationOptionsCommand.d.ts

@@ -1,38 +0,0 @@
-import { ElasticBeanstalkClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticBeanstalkClient";
-import { ConfigurationOptionsDescription, DescribeConfigurationOptionsMessage } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeConfigurationOptionsCommandInput extends DescribeConfigurationOptionsMessage {
-}
-export interface DescribeConfigurationOptionsCommandOutput extends ConfigurationOptionsDescription, __MetadataBearer {
-}
-/**
- * <p>Describes the configuration options that are used in a particular configuration
- *       template or environment, or that a specified solution stack defines. The description includes
- *       the values the options, their default values, and an indication of the required action on a
- *       running environment if an option value is changed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticBeanstalkClient, DescribeConfigurationOptionsCommand } from "@aws-sdk/client-elastic-beanstalk"; // ES Modules import
- * // const { ElasticBeanstalkClient, DescribeConfigurationOptionsCommand } = require("@aws-sdk/client-elastic-beanstalk"); // CommonJS import
- * const client = new ElasticBeanstalkClient(config);
- * const command = new DescribeConfigurationOptionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeConfigurationOptionsCommandInput} for command's `input` shape.
- * @see {@link DescribeConfigurationOptionsCommandOutput} for command's `response` shape.
- * @see {@link ElasticBeanstalkClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeConfigurationOptionsCommand extends $Command<DescribeConfigurationOptionsCommandInput, DescribeConfigurationOptionsCommandOutput, ElasticBeanstalkClientResolvedConfig> {
-    readonly input: DescribeConfigurationOptionsCommandInput;
-    constructor(input: DescribeConfigurationOptionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticBeanstalkClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeConfigurationOptionsCommandInput, DescribeConfigurationOptionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}