@aws-sdk/client-m2 3.107.0

package/dist-types/commands/CreateDataSetImportTaskCommand.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 { CreateDataSetImportTaskRequest, CreateDataSetImportTaskResponse } from "../models/models_0";
+export interface CreateDataSetImportTaskCommandInput extends CreateDataSetImportTaskRequest {
+}
+export interface CreateDataSetImportTaskCommandOutput extends CreateDataSetImportTaskResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts a data set import task for a specific application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, CreateDataSetImportTaskCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, CreateDataSetImportTaskCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new CreateDataSetImportTaskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDataSetImportTaskCommandInput} for command's `input` shape.
+ * @see {@link CreateDataSetImportTaskCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class CreateDataSetImportTaskCommand extends $Command<CreateDataSetImportTaskCommandInput, CreateDataSetImportTaskCommandOutput, M2ClientResolvedConfig> {
+    readonly input: CreateDataSetImportTaskCommandInput;
+    constructor(input: CreateDataSetImportTaskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataSetImportTaskCommandInput, CreateDataSetImportTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateDeploymentCommand.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 { CreateDeploymentRequest, CreateDeploymentResponse } from "../models/models_0";
+export interface CreateDeploymentCommandInput extends CreateDeploymentRequest {
+}
+export interface CreateDeploymentCommandOutput extends CreateDeploymentResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates and starts a deployment to deploy an application into an environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, CreateDeploymentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, CreateDeploymentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new CreateDeploymentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDeploymentCommandInput} for command's `input` shape.
+ * @see {@link CreateDeploymentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class CreateDeploymentCommand extends $Command<CreateDeploymentCommandInput, CreateDeploymentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: CreateDeploymentCommandInput;
+    constructor(input: CreateDeploymentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDeploymentCommandInput, CreateDeploymentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateEnvironmentCommand.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 { CreateEnvironmentRequest, CreateEnvironmentResponse } from "../models/models_0";
+export interface CreateEnvironmentCommandInput extends CreateEnvironmentRequest {
+}
+export interface CreateEnvironmentCommandOutput extends CreateEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a runtime environment for a given runtime engine.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, CreateEnvironmentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, CreateEnvironmentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(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 M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class CreateEnvironmentCommand extends $Command<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: CreateEnvironmentCommandInput;
+    constructor(input: CreateEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteApplicationCommand.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 { DeleteApplicationRequest, DeleteApplicationResponse } from "../models/models_0";
+export interface DeleteApplicationCommandInput extends DeleteApplicationRequest {
+}
+export interface DeleteApplicationCommandOutput extends DeleteApplicationResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific application. You cannot delete a running application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, DeleteApplicationCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, DeleteApplicationCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(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 M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class DeleteApplicationCommand extends $Command<DeleteApplicationCommandInput, DeleteApplicationCommandOutput, M2ClientResolvedConfig> {
+    readonly input: DeleteApplicationCommandInput;
+    constructor(input: DeleteApplicationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationCommandInput, DeleteApplicationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { DeleteApplicationFromEnvironmentRequest, DeleteApplicationFromEnvironmentResponse } from "../models/models_0";
+export interface DeleteApplicationFromEnvironmentCommandInput extends DeleteApplicationFromEnvironmentRequest {
+}
+export interface DeleteApplicationFromEnvironmentCommandOutput extends DeleteApplicationFromEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific application from a specified environment where it has been previously
+ *          deployed. You cannot delete an environment using DeleteEnvironment, if any application has
+ *          ever been deployed to it. This API removes the association of the application with the
+ *          environment so you can delete the environment smoothly.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, DeleteApplicationFromEnvironmentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, DeleteApplicationFromEnvironmentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new DeleteApplicationFromEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteApplicationFromEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link DeleteApplicationFromEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class DeleteApplicationFromEnvironmentCommand extends $Command<DeleteApplicationFromEnvironmentCommandInput, DeleteApplicationFromEnvironmentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: DeleteApplicationFromEnvironmentCommandInput;
+    constructor(input: DeleteApplicationFromEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationFromEnvironmentCommandInput, DeleteApplicationFromEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteEnvironmentCommand.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 { DeleteEnvironmentRequest, DeleteEnvironmentResponse } from "../models/models_0";
+export interface DeleteEnvironmentCommandInput extends DeleteEnvironmentRequest {
+}
+export interface DeleteEnvironmentCommandOutput extends DeleteEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a specific environment. The environment cannot contain deployed applications. If
+ *          it does, you must delete those applications before you delete the environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, DeleteEnvironmentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, DeleteEnvironmentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new DeleteEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link DeleteEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class DeleteEnvironmentCommand extends $Command<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: DeleteEnvironmentCommandInput;
+    constructor(input: DeleteEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetApplicationCommand.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 { GetApplicationRequest, GetApplicationResponse } from "../models/models_0";
+export interface GetApplicationCommandInput extends GetApplicationRequest {
+}
+export interface GetApplicationCommandOutput extends GetApplicationResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes the details of a specific application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetApplicationCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetApplicationCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetApplicationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetApplicationCommandInput} for command's `input` shape.
+ * @see {@link GetApplicationCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetApplicationCommand extends $Command<GetApplicationCommandInput, GetApplicationCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetApplicationCommandInput;
+    constructor(input: GetApplicationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetApplicationCommandInput, GetApplicationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetApplicationVersionCommand.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 { GetApplicationVersionRequest, GetApplicationVersionResponse } from "../models/models_0";
+export interface GetApplicationVersionCommandInput extends GetApplicationVersionRequest {
+}
+export interface GetApplicationVersionCommandOutput extends GetApplicationVersionResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns details about a specific version of a specific application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetApplicationVersionCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetApplicationVersionCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetApplicationVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetApplicationVersionCommandInput} for command's `input` shape.
+ * @see {@link GetApplicationVersionCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetApplicationVersionCommand extends $Command<GetApplicationVersionCommandInput, GetApplicationVersionCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetApplicationVersionCommandInput;
+    constructor(input: GetApplicationVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetApplicationVersionCommandInput, GetApplicationVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetBatchJobExecutionCommand.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 { GetBatchJobExecutionRequest, GetBatchJobExecutionResponse } from "../models/models_0";
+export interface GetBatchJobExecutionCommandInput extends GetBatchJobExecutionRequest {
+}
+export interface GetBatchJobExecutionCommandOutput extends GetBatchJobExecutionResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of a specific batch job execution for a specific application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetBatchJobExecutionCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetBatchJobExecutionCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetBatchJobExecutionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBatchJobExecutionCommandInput} for command's `input` shape.
+ * @see {@link GetBatchJobExecutionCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetBatchJobExecutionCommand extends $Command<GetBatchJobExecutionCommandInput, GetBatchJobExecutionCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetBatchJobExecutionCommandInput;
+    constructor(input: GetBatchJobExecutionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBatchJobExecutionCommandInput, GetBatchJobExecutionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDataSetDetailsCommand.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 { GetDataSetDetailsRequest, GetDataSetDetailsResponse } from "../models/models_0";
+export interface GetDataSetDetailsCommandInput extends GetDataSetDetailsRequest {
+}
+export interface GetDataSetDetailsCommandOutput extends GetDataSetDetailsResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of a specific data set.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetDataSetDetailsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetDataSetDetailsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetDataSetDetailsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDataSetDetailsCommandInput} for command's `input` shape.
+ * @see {@link GetDataSetDetailsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetDataSetDetailsCommand extends $Command<GetDataSetDetailsCommandInput, GetDataSetDetailsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetDataSetDetailsCommandInput;
+    constructor(input: GetDataSetDetailsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataSetDetailsCommandInput, GetDataSetDetailsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDataSetImportTaskCommand.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 { GetDataSetImportTaskRequest, GetDataSetImportTaskResponse } from "../models/models_0";
+export interface GetDataSetImportTaskCommandInput extends GetDataSetImportTaskRequest {
+}
+export interface GetDataSetImportTaskCommandOutput extends GetDataSetImportTaskResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the status of a data set import task initiated with the <a>CreateDataSetImportTask</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetDataSetImportTaskCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetDataSetImportTaskCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetDataSetImportTaskCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDataSetImportTaskCommandInput} for command's `input` shape.
+ * @see {@link GetDataSetImportTaskCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetDataSetImportTaskCommand extends $Command<GetDataSetImportTaskCommandInput, GetDataSetImportTaskCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetDataSetImportTaskCommandInput;
+    constructor(input: GetDataSetImportTaskCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataSetImportTaskCommandInput, GetDataSetImportTaskCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDeploymentCommand.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 { GetDeploymentRequest, GetDeploymentResponse } from "../models/models_0";
+export interface GetDeploymentCommandInput extends GetDeploymentRequest {
+}
+export interface GetDeploymentCommandOutput extends GetDeploymentResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets details of a specific deployment with a given deployment identifier.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetDeploymentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetDeploymentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetDeploymentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeploymentCommandInput} for command's `input` shape.
+ * @see {@link GetDeploymentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetDeploymentCommand extends $Command<GetDeploymentCommandInput, GetDeploymentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetDeploymentCommandInput;
+    constructor(input: GetDeploymentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeploymentCommandInput, GetDeploymentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetEnvironmentCommand.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 { GetEnvironmentRequest, GetEnvironmentResponse } from "../models/models_0";
+export interface GetEnvironmentCommandInput extends GetEnvironmentRequest {
+}
+export interface GetEnvironmentCommandOutput extends GetEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes a specific runtime environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, GetEnvironmentCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, GetEnvironmentCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new GetEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link GetEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class GetEnvironmentCommand extends $Command<GetEnvironmentCommandInput, GetEnvironmentCommandOutput, M2ClientResolvedConfig> {
+    readonly input: GetEnvironmentCommandInput;
+    constructor(input: GetEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEnvironmentCommandInput, GetEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListApplicationVersionsCommand.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 { ListApplicationVersionsRequest, ListApplicationVersionsResponse } from "../models/models_0";
+export interface ListApplicationVersionsCommandInput extends ListApplicationVersionsRequest {
+}
+export interface ListApplicationVersionsCommandOutput extends ListApplicationVersionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of the application versions for a specific application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListApplicationVersionsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListApplicationVersionsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListApplicationVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListApplicationVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListApplicationVersionsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListApplicationVersionsCommand extends $Command<ListApplicationVersionsCommandInput, ListApplicationVersionsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListApplicationVersionsCommandInput;
+    constructor(input: ListApplicationVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApplicationVersionsCommandInput, ListApplicationVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListApplicationsCommand.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 { ListApplicationsRequest, ListApplicationsResponse } from "../models/models_0";
+export interface ListApplicationsCommandInput extends ListApplicationsRequest {
+}
+export interface ListApplicationsCommandOutput extends ListApplicationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the applications associated with a specific Amazon Web Services account. You can provide the
+ *          unique identifier of a specific environment in a query parameter to see all applications
+ *          associated with that environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListApplicationsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListApplicationsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListApplicationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListApplicationsCommandInput} for command's `input` shape.
+ * @see {@link ListApplicationsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListApplicationsCommand extends $Command<ListApplicationsCommandInput, ListApplicationsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListApplicationsCommandInput;
+    constructor(input: ListApplicationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApplicationsCommandInput, ListApplicationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListBatchJobDefinitionsCommand.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 { ListBatchJobDefinitionsRequest, ListBatchJobDefinitionsResponse } from "../models/models_0";
+export interface ListBatchJobDefinitionsCommandInput extends ListBatchJobDefinitionsRequest {
+}
+export interface ListBatchJobDefinitionsCommandOutput extends ListBatchJobDefinitionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all the available batch job definitions based on the batch job resources uploaded
+ *          during the application creation. The listed batch job definitions can then be used to start
+ *          a batch job.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListBatchJobDefinitionsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListBatchJobDefinitionsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListBatchJobDefinitionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBatchJobDefinitionsCommandInput} for command's `input` shape.
+ * @see {@link ListBatchJobDefinitionsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListBatchJobDefinitionsCommand extends $Command<ListBatchJobDefinitionsCommandInput, ListBatchJobDefinitionsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListBatchJobDefinitionsCommandInput;
+    constructor(input: ListBatchJobDefinitionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBatchJobDefinitionsCommandInput, ListBatchJobDefinitionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListBatchJobExecutionsCommand.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 { ListBatchJobExecutionsRequest, ListBatchJobExecutionsResponse } from "../models/models_0";
+export interface ListBatchJobExecutionsCommandInput extends ListBatchJobExecutionsRequest {
+}
+export interface ListBatchJobExecutionsCommandOutput extends ListBatchJobExecutionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists historical, current, and scheduled batch job executions for a specific
+ *          application.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { M2Client, ListBatchJobExecutionsCommand } from "@aws-sdk/client-m2"; // ES Modules import
+ * // const { M2Client, ListBatchJobExecutionsCommand } = require("@aws-sdk/client-m2"); // CommonJS import
+ * const client = new M2Client(config);
+ * const command = new ListBatchJobExecutionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBatchJobExecutionsCommandInput} for command's `input` shape.
+ * @see {@link ListBatchJobExecutionsCommandOutput} for command's `response` shape.
+ * @see {@link M2ClientResolvedConfig | config} for M2Client's `config` shape.
+ *
+ */
+export declare class ListBatchJobExecutionsCommand extends $Command<ListBatchJobExecutionsCommandInput, ListBatchJobExecutionsCommandOutput, M2ClientResolvedConfig> {
+    readonly input: ListBatchJobExecutionsCommandInput;
+    constructor(input: ListBatchJobExecutionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: M2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBatchJobExecutionsCommandInput, ListBatchJobExecutionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}