@aws-sdk/client-mwaa-serverless 3.933.0

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

@@ -0,0 +1,106 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { ListWorkflowRunsRequest, ListWorkflowRunsResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListWorkflowRunsCommand}.
+ */
+export interface ListWorkflowRunsCommandInput extends ListWorkflowRunsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListWorkflowRunsCommand}.
+ */
+export interface ListWorkflowRunsCommandOutput extends ListWorkflowRunsResponse, __MetadataBearer {
+}
+declare const ListWorkflowRunsCommand_base: {
+    new (input: ListWorkflowRunsCommandInput): import("@smithy/smithy-client").CommandImpl<ListWorkflowRunsCommandInput, ListWorkflowRunsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: ListWorkflowRunsCommandInput): import("@smithy/smithy-client").CommandImpl<ListWorkflowRunsCommandInput, ListWorkflowRunsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Lists all runs for a specified workflow, with optional pagination and filtering support.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, ListWorkflowRunsCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, ListWorkflowRunsCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // ListWorkflowRunsRequest
+ *   MaxResults: Number("int"),
+ *   NextToken: "STRING_VALUE",
+ *   WorkflowArn: "STRING_VALUE", // required
+ *   WorkflowVersion: "STRING_VALUE",
+ * };
+ * const command = new ListWorkflowRunsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListWorkflowRunsResponse
+ * //   WorkflowRuns: [ // WorkflowRunSummaries
+ * //     { // WorkflowRunSummary
+ * //       RunId: "STRING_VALUE",
+ * //       WorkflowArn: "STRING_VALUE",
+ * //       WorkflowVersion: "STRING_VALUE",
+ * //       RunType: "ON_DEMAND" || "SCHEDULED",
+ * //       RunDetailSummary: { // RunDetailSummary
+ * //         Status: "STARTING" || "QUEUED" || "RUNNING" || "SUCCESS" || "FAILED" || "TIMEOUT" || "STOPPING" || "STOPPED",
+ * //         CreatedOn: new Date("TIMESTAMP"),
+ * //         StartedAt: new Date("TIMESTAMP"),
+ * //         EndedAt: new Date("TIMESTAMP"),
+ * //       },
+ * //     },
+ * //   ],
+ * //   NextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListWorkflowRunsCommandInput - {@link ListWorkflowRunsCommandInput}
+ * @returns {@link ListWorkflowRunsCommandOutput}
+ * @see {@link ListWorkflowRunsCommandInput} for command's `input` shape.
+ * @see {@link ListWorkflowRunsCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class ListWorkflowRunsCommand extends ListWorkflowRunsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListWorkflowRunsRequest;
+            output: ListWorkflowRunsResponse;
+        };
+        sdk: {
+            input: ListWorkflowRunsCommandInput;
+            output: ListWorkflowRunsCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,109 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { ListWorkflowVersionsRequest, ListWorkflowVersionsResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListWorkflowVersionsCommand}.
+ */
+export interface ListWorkflowVersionsCommandInput extends ListWorkflowVersionsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListWorkflowVersionsCommand}.
+ */
+export interface ListWorkflowVersionsCommandOutput extends ListWorkflowVersionsResponse, __MetadataBearer {
+}
+declare const ListWorkflowVersionsCommand_base: {
+    new (input: ListWorkflowVersionsCommandInput): import("@smithy/smithy-client").CommandImpl<ListWorkflowVersionsCommandInput, ListWorkflowVersionsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: ListWorkflowVersionsCommandInput): import("@smithy/smithy-client").CommandImpl<ListWorkflowVersionsCommandInput, ListWorkflowVersionsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Lists all versions of a specified workflow, with optional pagination support.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, ListWorkflowVersionsCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, ListWorkflowVersionsCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // ListWorkflowVersionsRequest
+ *   MaxResults: Number("int"),
+ *   NextToken: "STRING_VALUE",
+ *   WorkflowArn: "STRING_VALUE", // required
+ * };
+ * const command = new ListWorkflowVersionsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListWorkflowVersionsResponse
+ * //   WorkflowVersions: [ // WorkflowVersionSummaries
+ * //     { // WorkflowVersionSummary
+ * //       WorkflowVersion: "STRING_VALUE", // required
+ * //       WorkflowArn: "STRING_VALUE", // required
+ * //       IsLatestVersion: true || false,
+ * //       CreatedAt: new Date("TIMESTAMP"),
+ * //       ModifiedAt: new Date("TIMESTAMP"),
+ * //       DefinitionS3Location: { // DefinitionS3Location
+ * //         Bucket: "STRING_VALUE", // required
+ * //         ObjectKey: "STRING_VALUE", // required
+ * //         VersionId: "STRING_VALUE",
+ * //       },
+ * //       ScheduleConfiguration: { // ScheduleConfiguration
+ * //         CronExpression: "STRING_VALUE",
+ * //       },
+ * //       TriggerMode: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * //   NextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListWorkflowVersionsCommandInput - {@link ListWorkflowVersionsCommandInput}
+ * @returns {@link ListWorkflowVersionsCommandOutput}
+ * @see {@link ListWorkflowVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListWorkflowVersionsCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class ListWorkflowVersionsCommand extends ListWorkflowVersionsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListWorkflowVersionsRequest;
+            output: ListWorkflowVersionsResponse;
+        };
+        sdk: {
+            input: ListWorkflowVersionsCommandInput;
+            output: ListWorkflowVersionsCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,102 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { ListWorkflowsRequest, ListWorkflowsResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link ListWorkflowsCommand}.
+ */
+export interface ListWorkflowsCommandInput extends ListWorkflowsRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link ListWorkflowsCommand}.
+ */
+export interface ListWorkflowsCommandOutput extends ListWorkflowsResponse, __MetadataBearer {
+}
+declare const ListWorkflowsCommand_base: {
+    new (input: ListWorkflowsCommandInput): import("@smithy/smithy-client").CommandImpl<ListWorkflowsCommandInput, ListWorkflowsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (...[input]: [] | [ListWorkflowsCommandInput]): import("@smithy/smithy-client").CommandImpl<ListWorkflowsCommandInput, ListWorkflowsCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Lists all workflows in your account, with optional pagination support. This operation returns summary information for workflows, showing only the most recently created version of each workflow. Amazon Managed Workflows for Apache Airflow Serverless maintains workflow metadata in a highly available, distributed storage system that enables efficient querying and filtering. The service implements proper access controls to ensure you can only view workflows that you have permissions to access, supporting both individual and team-based workflow management scenarios.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, ListWorkflowsCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, ListWorkflowsCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // ListWorkflowsRequest
+ *   MaxResults: Number("int"),
+ *   NextToken: "STRING_VALUE",
+ * };
+ * const command = new ListWorkflowsCommand(input);
+ * const response = await client.send(command);
+ * // { // ListWorkflowsResponse
+ * //   Workflows: [ // WorkflowSummaries // required
+ * //     { // WorkflowSummary
+ * //       WorkflowArn: "STRING_VALUE", // required
+ * //       WorkflowVersion: "STRING_VALUE",
+ * //       Name: "STRING_VALUE",
+ * //       Description: "STRING_VALUE",
+ * //       CreatedAt: new Date("TIMESTAMP"),
+ * //       ModifiedAt: new Date("TIMESTAMP"),
+ * //       WorkflowStatus: "READY" || "DELETING",
+ * //       TriggerMode: "STRING_VALUE",
+ * //     },
+ * //   ],
+ * //   NextToken: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param ListWorkflowsCommandInput - {@link ListWorkflowsCommandInput}
+ * @returns {@link ListWorkflowsCommandOutput}
+ * @see {@link ListWorkflowsCommandInput} for command's `input` shape.
+ * @see {@link ListWorkflowsCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class ListWorkflowsCommand extends ListWorkflowsCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: ListWorkflowsRequest;
+            output: ListWorkflowsResponse;
+        };
+        sdk: {
+            input: ListWorkflowsCommandInput;
+            output: ListWorkflowsCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,105 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { StartWorkflowRunRequest, StartWorkflowRunResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link StartWorkflowRunCommand}.
+ */
+export interface StartWorkflowRunCommandInput extends StartWorkflowRunRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StartWorkflowRunCommand}.
+ */
+export interface StartWorkflowRunCommandOutput extends StartWorkflowRunResponse, __MetadataBearer {
+}
+declare const StartWorkflowRunCommand_base: {
+    new (input: StartWorkflowRunCommandInput): import("@smithy/smithy-client").CommandImpl<StartWorkflowRunCommandInput, StartWorkflowRunCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: StartWorkflowRunCommandInput): import("@smithy/smithy-client").CommandImpl<StartWorkflowRunCommandInput, StartWorkflowRunCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Starts a new execution of a workflow. This operation creates a workflow run that executes the tasks that are defined in the workflow. Amazon Managed Workflows for Apache Airflow Serverless schedules the workflow execution across its managed Airflow environment, automatically scaling ECS worker tasks based on the workload. The service handles task isolation, dependency resolution, and provides comprehensive monitoring and logging throughout the execution lifecycle.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, StartWorkflowRunCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, StartWorkflowRunCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // StartWorkflowRunRequest
+ *   WorkflowArn: "STRING_VALUE", // required
+ *   ClientToken: "STRING_VALUE",
+ *   OverrideParameters: { // ObjectMap
+ *     "<keys>": "DOCUMENT_VALUE",
+ *   },
+ *   WorkflowVersion: "STRING_VALUE",
+ * };
+ * const command = new StartWorkflowRunCommand(input);
+ * const response = await client.send(command);
+ * // { // StartWorkflowRunResponse
+ * //   RunId: "STRING_VALUE",
+ * //   Status: "STARTING" || "QUEUED" || "RUNNING" || "SUCCESS" || "FAILED" || "TIMEOUT" || "STOPPING" || "STOPPED",
+ * //   StartedAt: new Date("TIMESTAMP"),
+ * // };
+ *
+ * ```
+ *
+ * @param StartWorkflowRunCommandInput - {@link StartWorkflowRunCommandInput}
+ * @returns {@link StartWorkflowRunCommandOutput}
+ * @see {@link StartWorkflowRunCommandInput} for command's `input` shape.
+ * @see {@link StartWorkflowRunCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link ConflictException} (client fault)
+ *  <p>You cannot create a resource that already exists, or the resource is in a state that prevents the requested operation.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource was not found. You can only access or modify a resource that already exists.</p>
+ *
+ * @throws {@link ServiceQuotaExceededException} (client fault)
+ *  <p>The request exceeds the service quota for Amazon Managed Workflows for Apache Airflow Serverless resources. This can occur when you attempt to create more workflows than allowed, exceed concurrent workflow run limits, or surpass task execution limits. Amazon Managed Workflows for Apache Airflow Serverless implements admission control using DynamoDB-based counters to manage resource utilization across the multi-tenant environment. Contact Amazon Web Services Support to request quota increases if you need higher limits for your use case.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class StartWorkflowRunCommand extends StartWorkflowRunCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: StartWorkflowRunRequest;
+            output: StartWorkflowRunResponse;
+        };
+        sdk: {
+            input: StartWorkflowRunCommandInput;
+            output: StartWorkflowRunCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,96 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { StopWorkflowRunRequest, StopWorkflowRunResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link StopWorkflowRunCommand}.
+ */
+export interface StopWorkflowRunCommandInput extends StopWorkflowRunRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link StopWorkflowRunCommand}.
+ */
+export interface StopWorkflowRunCommandOutput extends StopWorkflowRunResponse, __MetadataBearer {
+}
+declare const StopWorkflowRunCommand_base: {
+    new (input: StopWorkflowRunCommandInput): import("@smithy/smithy-client").CommandImpl<StopWorkflowRunCommandInput, StopWorkflowRunCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: StopWorkflowRunCommandInput): import("@smithy/smithy-client").CommandImpl<StopWorkflowRunCommandInput, StopWorkflowRunCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Stops a running workflow execution. This operation terminates all running tasks and prevents new tasks from starting. Amazon Managed Workflows for Apache Airflow Serverless gracefully shuts down the workflow execution by stopping task scheduling and terminating active ECS worker containers. The operation transitions the workflow run to a <code>STOPPING</code> state and then to <code>STOPPED</code> once all cleanup is complete. In-flight tasks may complete or be terminated depending on their current execution state.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, StopWorkflowRunCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, StopWorkflowRunCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // StopWorkflowRunRequest
+ *   WorkflowArn: "STRING_VALUE", // required
+ *   RunId: "STRING_VALUE", // required
+ * };
+ * const command = new StopWorkflowRunCommand(input);
+ * const response = await client.send(command);
+ * // { // StopWorkflowRunResponse
+ * //   WorkflowArn: "STRING_VALUE",
+ * //   WorkflowVersion: "STRING_VALUE",
+ * //   RunId: "STRING_VALUE",
+ * //   Status: "STARTING" || "QUEUED" || "RUNNING" || "SUCCESS" || "FAILED" || "TIMEOUT" || "STOPPING" || "STOPPED",
+ * // };
+ *
+ * ```
+ *
+ * @param StopWorkflowRunCommandInput - {@link StopWorkflowRunCommandInput}
+ * @returns {@link StopWorkflowRunCommandOutput}
+ * @see {@link StopWorkflowRunCommandInput} for command's `input` shape.
+ * @see {@link StopWorkflowRunCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource was not found. You can only access or modify a resource that already exists.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class StopWorkflowRunCommand extends StopWorkflowRunCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: StopWorkflowRunRequest;
+            output: StopWorkflowRunResponse;
+        };
+        sdk: {
+            input: StopWorkflowRunCommandInput;
+            output: StopWorkflowRunCommandOutput;
+        };
+    };
+}

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

@@ -0,0 +1,93 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_0";
+import { MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MWAAServerlessClient";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link TagResourceCommand}.
+ */
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link TagResourceCommand}.
+ */
+export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
+}
+declare const TagResourceCommand_base: {
+    new (input: TagResourceCommandInput): import("@smithy/smithy-client").CommandImpl<TagResourceCommandInput, TagResourceCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: TagResourceCommandInput): import("@smithy/smithy-client").CommandImpl<TagResourceCommandInput, TagResourceCommandOutput, MWAAServerlessClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Adds tags to an Amazon Managed Workflows for Apache Airflow Serverless resource. Tags are key-value pairs that help you organize and categorize your resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { MWAAServerlessClient, TagResourceCommand } from "@aws-sdk/client-mwaa-serverless"; // ES Modules import
+ * // const { MWAAServerlessClient, TagResourceCommand } = require("@aws-sdk/client-mwaa-serverless"); // CommonJS import
+ * // import type { MWAAServerlessClientConfig } from "@aws-sdk/client-mwaa-serverless";
+ * const config = {}; // type is MWAAServerlessClientConfig
+ * const client = new MWAAServerlessClient(config);
+ * const input = { // TagResourceRequest
+ *   ResourceArn: "STRING_VALUE", // required
+ *   Tags: { // Tags // required
+ *     "<keys>": "STRING_VALUE",
+ *   },
+ * };
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param TagResourceCommandInput - {@link TagResourceCommandInput}
+ * @returns {@link TagResourceCommandOutput}
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link MWAAServerlessClientResolvedConfig | config} for MWAAServerlessClient's `config` shape.
+ *
+ * @throws {@link AccessDeniedException} (client fault)
+ *  <p>You do not have sufficient permission to perform this action.</p>
+ *
+ * @throws {@link InternalServerException} (server fault)
+ *  <p>An unexpected server-side error occurred during request processing.</p>
+ *
+ * @throws {@link OperationTimeoutException} (server fault)
+ *  <p>The operation timed out.</p>
+ *
+ * @throws {@link ResourceNotFoundException} (client fault)
+ *  <p>The specified resource was not found. You can only access or modify a resource that already exists.</p>
+ *
+ * @throws {@link ThrottlingException} (client fault)
+ *  <p>The request was denied because too many requests were made in a short period, exceeding the service rate limits. Amazon Managed Workflows for Apache Airflow Serverless implements throttling controls to ensure fair resource allocation across all customers in the multi-tenant environment. This helps maintain service stability and performance. If you encounter throttling, implement exponential backoff and retry logic in your applications, or consider distributing your API calls over a longer time period.</p>
+ *
+ * @throws {@link ValidationException} (client fault)
+ *  <p>The specified request parameters are invalid, missing, or inconsistent with Amazon Managed Workflows for Apache Airflow Serverless service requirements. This can occur when workflow definitions contain unsupported operators, when required IAM permissions are missing, when S3 locations are inaccessible, or when network configurations are invalid. The service validates workflow definitions, execution roles, and resource configurations to ensure compatibility with the managed Airflow environment and security requirements.</p>
+ *
+ * @throws {@link MWAAServerlessServiceException}
+ * <p>Base exception class for all service exceptions from MWAAServerless service.</p>
+ *
+ *
+ * @public
+ */
+export declare class TagResourceCommand extends TagResourceCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: TagResourceRequest;
+            output: {};
+        };
+        sdk: {
+            input: TagResourceCommandInput;
+            output: TagResourceCommandOutput;
+        };
+    };
+}