@aws-sdk/client-m2 3.107.0

package/dist-types/commands/ListDataSetImportHistoryCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListDataSetImportHistoryRequest, ListDataSetImportHistoryResponse } from "../models/models_0";
+export interface ListDataSetImportHistoryCommandInput extends ListDataSetImportHistoryRequest {
+}
+export interface ListDataSetImportHistoryCommandOutput extends ListDataSetImportHistoryResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the data set imports for the specified application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListDataSetImportHistoryCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListDataSetImportHistoryCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListDataSetImportHistoryCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDataSetImportHistoryCommandInput} for command's `input` shape.
+ * @see {@link ListDataSetImportHistoryCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListDataSetImportHistoryCommand extends $Command<ListDataSetImportHistoryCommandInput, ListDataSetImportHistoryCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListDataSetImportHistoryCommandInput;
+    constructor(input: ListDataSetImportHistoryCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDataSetImportHistoryCommandInput, ListDataSetImportHistoryCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDataSetsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListDataSetsRequest, ListDataSetsResponse } from "../models/models_0";
+export interface ListDataSetsCommandInput extends ListDataSetsRequest {
+}
+export interface ListDataSetsCommandOutput extends ListDataSetsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the data sets imported for a specific application. In Amazon Web Services Mainframe Modernization, data sets are
+ *          associated with applications deployed on environments. This is known as importing data
+ *          sets. Currently, Amazon Web Services Mainframe Modernization can import data sets into catalogs using <a href="https://docs.aws.amazon.com/m2/latest/APIReference/API_CreateDataSetImportTask.html">CreateDataSetImportTask</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListDataSetsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListDataSetsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListDataSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDataSetsCommandInput} for command's `input` shape.
+ * @see {@link ListDataSetsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListDataSetsCommand extends $Command<ListDataSetsCommandInput, ListDataSetsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListDataSetsCommandInput;
+    constructor(input: ListDataSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDataSetsCommandInput, ListDataSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDeploymentsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListDeploymentsRequest, ListDeploymentsResponse } from "../models/models_0";
+export interface ListDeploymentsCommandInput extends ListDeploymentsRequest {
+}
+export interface ListDeploymentsCommandOutput extends ListDeploymentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of all deployments of a specific application. A deployment is a
+ *          combination of a specific application and a specific version of that application. Each
+ *          deployment is mapped to a particular application version.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListDeploymentsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListDeploymentsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListDeploymentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDeploymentsCommandInput} for command's `input` shape.
+ * @see {@link ListDeploymentsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListDeploymentsCommand extends $Command<ListDeploymentsCommandInput, ListDeploymentsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListDeploymentsCommandInput;
+    constructor(input: ListDeploymentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDeploymentsCommandInput, ListDeploymentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListEngineVersionsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListEngineVersionsRequest, ListEngineVersionsResponse } from "../models/models_0";
+export interface ListEngineVersionsCommandInput extends ListEngineVersionsRequest {
+}
+export interface ListEngineVersionsCommandOutput extends ListEngineVersionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the available engine versions.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListEngineVersionsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListEngineVersionsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListEngineVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListEngineVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListEngineVersionsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListEngineVersionsCommand extends $Command<ListEngineVersionsCommandInput, ListEngineVersionsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListEngineVersionsCommandInput;
+    constructor(input: ListEngineVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEngineVersionsCommandInput, ListEngineVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListEnvironmentsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListEnvironmentsRequest, ListEnvironmentsResponse } from "../models/models_0";
+export interface ListEnvironmentsCommandInput extends ListEnvironmentsRequest {
+}
+export interface ListEnvironmentsCommandOutput extends ListEnvironmentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the runtime environments.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListEnvironmentsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListEnvironmentsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListEnvironmentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListEnvironmentsCommandInput} for command's `input` shape.
+ * @see {@link ListEnvironmentsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListEnvironmentsCommand extends $Command<ListEnvironmentsCommandInput, ListEnvironmentsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListEnvironmentsCommandInput;
+    constructor(input: ListEnvironmentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEnvironmentsCommandInput, ListEnvironmentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the tags for the specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListTagsForResourceCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListTagsForResourceCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartApplicationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { StartApplicationRequest, StartApplicationResponse } from "../models/models_0";
+export interface StartApplicationCommandInput extends StartApplicationRequest {
+}
+export interface StartApplicationCommandOutput extends StartApplicationResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts an application that is currently stopped.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, StartApplicationCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, StartApplicationCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new StartApplicationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartApplicationCommandInput} for command's `input` shape.
+ * @see {@link StartApplicationCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class StartApplicationCommand extends $Command<StartApplicationCommandInput, StartApplicationCommandOutput, M2ClientResolvedConfig> {
+    readonly input: StartApplicationCommandInput;
+    constructor(input: StartApplicationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartApplicationCommandInput, StartApplicationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartBatchJobCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { StartBatchJobRequest, StartBatchJobResponse } from "../models/models_0";
+export interface StartBatchJobCommandInput extends StartBatchJobRequest {
+}
+export interface StartBatchJobCommandOutput extends StartBatchJobResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts a batch job and returns the unique identifier of this execution of the batch job.
+ *          The associated application must be running in order to start the batch job.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, StartBatchJobCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, StartBatchJobCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new StartBatchJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartBatchJobCommandInput} for command's `input` shape.
+ * @see {@link StartBatchJobCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class StartBatchJobCommand extends $Command<StartBatchJobCommandInput, StartBatchJobCommandOutput, M2ClientResolvedConfig> {
+    readonly input: StartBatchJobCommandInput;
+    constructor(input: StartBatchJobCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartBatchJobCommandInput, StartBatchJobCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StopApplicationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { StopApplicationRequest, StopApplicationResponse } from "../models/models_0";
+export interface StopApplicationCommandInput extends StopApplicationRequest {
+}
+export interface StopApplicationCommandOutput extends StopApplicationResponse, __MetadataBearer {
+}
+/**
+ * <p>Stops a running application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, StopApplicationCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, StopApplicationCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new StopApplicationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopApplicationCommandInput} for command's `input` shape.
+ * @see {@link StopApplicationCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class StopApplicationCommand extends $Command<StopApplicationCommandInput, StopApplicationCommandOutput, M2ClientResolvedConfig> {
+    readonly input: StopApplicationCommandInput;
+    constructor(input: StopApplicationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopApplicationCommandInput, StopApplicationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Adds one or more tags to the specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, TagResourceCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, TagResourceCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, M2ClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_0";
+export interface UntagResourceCommandInput extends UntagResourceRequest {
+}
+export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes one or more tags from the specified resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, UntagResourceCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, UntagResourceCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, M2ClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateApplicationCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { UpdateApplicationRequest, UpdateApplicationResponse } from "../models/models_0";
+export interface UpdateApplicationCommandInput extends UpdateApplicationRequest {
+}
+export interface UpdateApplicationCommandOutput extends UpdateApplicationResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates an application and creates a new version.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, UpdateApplicationCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, UpdateApplicationCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new UpdateApplicationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateApplicationCommandInput} for command's `input` shape.
+ * @see {@link UpdateApplicationCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class UpdateApplicationCommand extends $Command<UpdateApplicationCommandInput, UpdateApplicationCommandOutput, M2ClientResolvedConfig> {
+    readonly input: UpdateApplicationCommandInput;
+    constructor(input: UpdateApplicationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApplicationCommandInput, UpdateApplicationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateEnvironmentCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { M2ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../M2Client";
+import { UpdateEnvironmentRequest, UpdateEnvironmentResponse } from "../models/models_0";
+export interface UpdateEnvironmentCommandInput extends UpdateEnvironmentRequest {
+}
+export interface UpdateEnvironmentCommandOutput extends UpdateEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the configuration details for a specific environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, UpdateEnvironmentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, UpdateEnvironmentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new UpdateEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link UpdateEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class UpdateEnvironmentCommand extends $Command<UpdateEnvironmentCommandInput, UpdateEnvironmentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: UpdateEnvironmentCommandInput;
+    constructor(input: UpdateEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEnvironmentCommandInput, UpdateEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./CancelBatchJobExecutionCommand";
+export * from "./CreateApplicationCommand";
+export * from "./CreateDataSetImportTaskCommand";
+export * from "./CreateDeploymentCommand";
+export * from "./CreateEnvironmentCommand";
+export * from "./DeleteApplicationCommand";
+export * from "./DeleteApplicationFromEnvironmentCommand";
+export * from "./DeleteEnvironmentCommand";
+export * from "./GetApplicationCommand";
+export * from "./GetApplicationVersionCommand";
+export * from "./GetBatchJobExecutionCommand";
+export * from "./GetDataSetDetailsCommand";
+export * from "./GetDataSetImportTaskCommand";
+export * from "./GetDeploymentCommand";
+export * from "./GetEnvironmentCommand";
+export * from "./ListApplicationVersionsCommand";
+export * from "./ListApplicationsCommand";
+export * from "./ListBatchJobDefinitionsCommand";
+export * from "./ListBatchJobExecutionsCommand";
+export * from "./ListDataSetImportHistoryCommand";
+export * from "./ListDataSetsCommand";
+export * from "./ListDeploymentsCommand";
+export * from "./ListEngineVersionsCommand";
+export * from "./ListEnvironmentsCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./StartApplicationCommand";
+export * from "./StartBatchJobCommand";
+export * from "./StopApplicationCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateApplicationCommand";
+export * from "./UpdateEnvironmentCommand";

package/dist-types/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { RegionInfoProvider } from "@aws-sdk/types";
+export declare const defaultRegionInfoProvider: RegionInfoProvider;

package/dist-types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./M2";
+export * from "./M2Client";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { M2ServiceException } from "./models/M2ServiceException";

package/dist-types/models/M2ServiceException.d.ts

@@ -0,0 +1,10 @@
+import { ServiceException as __ServiceException, ServiceExceptionOptions as __ServiceExceptionOptions } from "@aws-sdk/smithy-client";
+/**
+ * Base exception class for all service exceptions from M2 service.
+ */
+export declare class M2ServiceException extends __ServiceException {
+    /**
+     * @internal
+     */
+    constructor(options: __ServiceExceptionOptions);
+}

package/dist-types/models/index.d.ts

@@ -0,0 +1 @@
+export * from "./models_0";