@aws-sdk/client-batch 3.521.0 → 3.524.0

package/dist-cjs/index.js

@@ -665,9 +665,10 @@ var se_RegisterJobDefinitionCommand = /* @__PURE__ */ __name(async (input, conte
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
       containerProperties: (_) => (0, import_smithy_client._json)(_),
+      ecsProperties: (_) => (0, import_smithy_client._json)(_),
       eksProperties: (_) => (0, import_smithy_client._json)(_),
       jobDefinitionName: [],
-      nodeProperties: (_) => (0, import_smithy_client._json)(_),
+      nodeProperties: (_) => se_NodeProperties(_, context),
       parameters: (_) => (0, import_smithy_client._json)(_),
       platformCapabilities: (_) => (0, import_smithy_client._json)(_),
       propagateTags: [],
@@ -693,6 +694,7 @@ var se_SubmitJobCommand = /* @__PURE__ */ __name(async (input, context) => {
       arrayProperties: (_) => (0, import_smithy_client._json)(_),
       containerOverrides: (_) => (0, import_smithy_client._json)(_),
       dependsOn: (_) => (0, import_smithy_client._json)(_),
+      ecsPropertiesOverride: (_) => (0, import_smithy_client._json)(_),
       eksPropertiesOverride: (_) => (0, import_smithy_client._json)(_),
       jobDefinition: [],
       jobName: [],
@@ -931,7 +933,7 @@ var de_DescribeJobDefinitionsCommand = /* @__PURE__ */ __name(async (output, con
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    jobDefinitions: import_smithy_client._json,
+    jobDefinitions: (_) => de_JobDefinitionList(_, context),
     nextToken: import_smithy_client.expectString
   });
   Object.assign(contents, doc);
@@ -961,7 +963,7 @@ var de_DescribeJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    jobs: import_smithy_client._json
+    jobs: (_) => de_JobDetailList(_, context)
   });
   Object.assign(contents, doc);
   return contents;
@@ -1182,6 +1184,18 @@ var se_FairsharePolicy = /* @__PURE__ */ __name((input, context) => {
     shareDistribution: (_) => se_ShareAttributesList(_, context)
   });
 }, "se_FairsharePolicy");
+var se_NodeProperties = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    mainNode: [],
+    nodeRangeProperties: (_) => se_NodeRangeProperties(_, context),
+    numNodes: []
+  });
+}, "se_NodeProperties");
+var se_NodeRangeProperties = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client._json)(entry);
+  });
+}, "se_NodeRangeProperties");
 var se_ShareAttributes = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     shareIdentifier: [],
@@ -1200,6 +1214,85 @@ var de_FairsharePolicy = /* @__PURE__ */ __name((output, context) => {
     shareDistribution: (_) => de_ShareAttributesList(_, context)
   });
 }, "de_FairsharePolicy");
+var de_JobDefinition = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    containerOrchestrationType: import_smithy_client.expectString,
+    containerProperties: import_smithy_client._json,
+    ecsProperties: import_smithy_client._json,
+    eksProperties: import_smithy_client._json,
+    jobDefinitionArn: import_smithy_client.expectString,
+    jobDefinitionName: import_smithy_client.expectString,
+    nodeProperties: (_) => de_NodeProperties(_, context),
+    parameters: import_smithy_client._json,
+    platformCapabilities: import_smithy_client._json,
+    propagateTags: import_smithy_client.expectBoolean,
+    retryStrategy: import_smithy_client._json,
+    revision: import_smithy_client.expectInt32,
+    schedulingPriority: import_smithy_client.expectInt32,
+    status: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    timeout: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_JobDefinition");
+var de_JobDefinitionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_JobDefinition(entry, context);
+  });
+  return retVal;
+}, "de_JobDefinitionList");
+var de_JobDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arrayProperties: import_smithy_client._json,
+    attempts: import_smithy_client._json,
+    container: import_smithy_client._json,
+    createdAt: import_smithy_client.expectLong,
+    dependsOn: import_smithy_client._json,
+    ecsProperties: import_smithy_client._json,
+    eksAttempts: import_smithy_client._json,
+    eksProperties: import_smithy_client._json,
+    isCancelled: import_smithy_client.expectBoolean,
+    isTerminated: import_smithy_client.expectBoolean,
+    jobArn: import_smithy_client.expectString,
+    jobDefinition: import_smithy_client.expectString,
+    jobId: import_smithy_client.expectString,
+    jobName: import_smithy_client.expectString,
+    jobQueue: import_smithy_client.expectString,
+    nodeDetails: import_smithy_client._json,
+    nodeProperties: (_) => de_NodeProperties(_, context),
+    parameters: import_smithy_client._json,
+    platformCapabilities: import_smithy_client._json,
+    propagateTags: import_smithy_client.expectBoolean,
+    retryStrategy: import_smithy_client._json,
+    schedulingPriority: import_smithy_client.expectInt32,
+    shareIdentifier: import_smithy_client.expectString,
+    startedAt: import_smithy_client.expectLong,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    stoppedAt: import_smithy_client.expectLong,
+    tags: import_smithy_client._json,
+    timeout: import_smithy_client._json
+  });
+}, "de_JobDetail");
+var de_JobDetailList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_JobDetail(entry, context);
+  });
+  return retVal;
+}, "de_JobDetailList");
+var de_NodeProperties = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    mainNode: import_smithy_client.expectInt32,
+    nodeRangeProperties: (_) => de_NodeRangeProperties(_, context),
+    numNodes: import_smithy_client.expectInt32
+  });
+}, "de_NodeProperties");
+var de_NodeRangeProperties = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client._json)(entry);
+  });
+  return retVal;
+}, "de_NodeRangeProperties");
 var de_SchedulingPolicyDetail = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     arn: import_smithy_client.expectString,

package/dist-es/protocols/Aws_restJson1.js

@@ -1,5 +1,5 @@
 import { requestBuilder as rb } from "@smithy/core";
-import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
 import { BatchServiceException as __BaseException } from "../models/BatchServiceException";
 import { ClientException, ServerException, } from "../models/models_0";
 export const se_CancelJobCommand = async (input, context) => {
@@ -245,9 +245,10 @@ export const se_RegisterJobDefinitionCommand = async (input, context) => {
     let body;
     body = JSON.stringify(take(input, {
         containerProperties: (_) => _json(_),
+        ecsProperties: (_) => _json(_),
         eksProperties: (_) => _json(_),
         jobDefinitionName: [],
-        nodeProperties: (_) => _json(_),
+        nodeProperties: (_) => se_NodeProperties(_, context),
         parameters: (_) => _json(_),
         platformCapabilities: (_) => _json(_),
         propagateTags: [],
@@ -271,6 +272,7 @@ export const se_SubmitJobCommand = async (input, context) => {
         arrayProperties: (_) => _json(_),
         containerOverrides: (_) => _json(_),
         dependsOn: (_) => _json(_),
+        ecsPropertiesOverride: (_) => _json(_),
         eksPropertiesOverride: (_) => _json(_),
         jobDefinition: [],
         jobName: [],
@@ -498,7 +500,7 @@ export const de_DescribeJobDefinitionsCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        jobDefinitions: _json,
+        jobDefinitions: (_) => de_JobDefinitionList(_, context),
         nextToken: __expectString,
     });
     Object.assign(contents, doc);
@@ -528,7 +530,7 @@ export const de_DescribeJobsCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
-        jobs: _json,
+        jobs: (_) => de_JobDetailList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -749,6 +751,20 @@ const se_FairsharePolicy = (input, context) => {
         shareDistribution: (_) => se_ShareAttributesList(_, context),
     });
 };
+const se_NodeProperties = (input, context) => {
+    return take(input, {
+        mainNode: [],
+        nodeRangeProperties: (_) => se_NodeRangeProperties(_, context),
+        numNodes: [],
+    });
+};
+const se_NodeRangeProperties = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return _json(entry);
+    });
+};
 const se_ShareAttributes = (input, context) => {
     return take(input, {
         shareIdentifier: [],
@@ -769,6 +785,91 @@ const de_FairsharePolicy = (output, context) => {
         shareDistribution: (_) => de_ShareAttributesList(_, context),
     });
 };
+const de_JobDefinition = (output, context) => {
+    return take(output, {
+        containerOrchestrationType: __expectString,
+        containerProperties: _json,
+        ecsProperties: _json,
+        eksProperties: _json,
+        jobDefinitionArn: __expectString,
+        jobDefinitionName: __expectString,
+        nodeProperties: (_) => de_NodeProperties(_, context),
+        parameters: _json,
+        platformCapabilities: _json,
+        propagateTags: __expectBoolean,
+        retryStrategy: _json,
+        revision: __expectInt32,
+        schedulingPriority: __expectInt32,
+        status: __expectString,
+        tags: _json,
+        timeout: _json,
+        type: __expectString,
+    });
+};
+const de_JobDefinitionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_JobDefinition(entry, context);
+    });
+    return retVal;
+};
+const de_JobDetail = (output, context) => {
+    return take(output, {
+        arrayProperties: _json,
+        attempts: _json,
+        container: _json,
+        createdAt: __expectLong,
+        dependsOn: _json,
+        ecsProperties: _json,
+        eksAttempts: _json,
+        eksProperties: _json,
+        isCancelled: __expectBoolean,
+        isTerminated: __expectBoolean,
+        jobArn: __expectString,
+        jobDefinition: __expectString,
+        jobId: __expectString,
+        jobName: __expectString,
+        jobQueue: __expectString,
+        nodeDetails: _json,
+        nodeProperties: (_) => de_NodeProperties(_, context),
+        parameters: _json,
+        platformCapabilities: _json,
+        propagateTags: __expectBoolean,
+        retryStrategy: _json,
+        schedulingPriority: __expectInt32,
+        shareIdentifier: __expectString,
+        startedAt: __expectLong,
+        status: __expectString,
+        statusReason: __expectString,
+        stoppedAt: __expectLong,
+        tags: _json,
+        timeout: _json,
+    });
+};
+const de_JobDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_JobDetail(entry, context);
+    });
+    return retVal;
+};
+const de_NodeProperties = (output, context) => {
+    return take(output, {
+        mainNode: __expectInt32,
+        nodeRangeProperties: (_) => de_NodeRangeProperties(_, context),
+        numNodes: __expectInt32,
+    });
+};
+const de_NodeRangeProperties = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return _json(entry);
+    });
+    return retVal;
+};
 const de_SchedulingPolicyDetail = (output, context) => {
     return take(output, {
         arn: __expectString,

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

@@ -26,35 +26,42 @@ declare const CreateComputeEnvironmentCommand_base: {
 };
 /**
  * @public
- * <p>Creates an Batch compute environment. You can create <code>MANAGED</code> or <code>UNMANAGED</code> compute
- *    environments. <code>MANAGED</code> compute environments can use Amazon EC2 or Fargate resources.
- *     <code>UNMANAGED</code> compute environments can only use EC2 resources.</p>
- *          <p>In a managed compute environment, Batch manages the capacity and instance types of the compute resources
- *    within the environment. This is based on the compute resource specification that you define or the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch template</a> that you
- *    specify when you create the compute environment. Either, you can choose to use EC2 On-Demand Instances and EC2 Spot
- *    Instances. Or, you can use Fargate and Fargate Spot capacity in your managed compute environment. You can
- *    optionally set a maximum price so that Spot Instances only launch when the Spot Instance price is less than a
- *    specified percentage of the On-Demand price.</p>
+ * <p>Creates an Batch compute environment. You can create <code>MANAGED</code> or
+ *         <code>UNMANAGED</code> compute environments. <code>MANAGED</code> compute environments can
+ *       use Amazon EC2 or Fargate resources. <code>UNMANAGED</code> compute environments can only use
+ *       EC2 resources.</p>
+ *          <p>In a managed compute environment, Batch manages the capacity and instance types of the
+ *       compute resources within the environment. This is based on the compute resource specification
+ *       that you define or the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch template</a> that you
+ *       specify when you create the compute environment. Either, you can choose to use EC2 On-Demand
+ *       Instances and EC2 Spot Instances. Or, you can use Fargate and Fargate Spot capacity in
+ *       your managed compute environment. You can optionally set a maximum price so that Spot
+ *       Instances only launch when the Spot Instance price is less than a specified percentage of the
+ *       On-Demand price.</p>
  *          <note>
  *             <p>Multi-node parallel jobs aren't supported on Spot Instances.</p>
  *          </note>
- *          <p>In an unmanaged compute environment, you can manage your own EC2 compute resources and have flexibility with how
- *    you configure your compute resources. For example, you can use custom AMIs. However, you must verify that each of
- *    your AMIs meet the Amazon ECS container instance AMI specification. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container_instance_AMIs.html">container instance AMIs</a> in the
- *    <i>Amazon Elastic Container Service Developer Guide</i>. After you created your unmanaged compute environment, you can use the <a>DescribeComputeEnvironments</a> operation to find the Amazon ECS cluster that's associated with it. Then, launch
- *    your container instances into that Amazon ECS cluster. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_container_instance.html">Launching an Amazon ECS container instance</a> in the
- *    <i>Amazon Elastic Container Service Developer Guide</i>.</p>
+ *          <p>In an unmanaged compute environment, you can manage your own EC2 compute resources and
+ *       have flexibility with how you configure your compute resources. For example, you can use
+ *       custom AMIs. However, you must verify that each of your AMIs meet the Amazon ECS container instance
+ *       AMI specification. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/container_instance_AMIs.html">container instance AMIs</a> in the
+ *         <i>Amazon Elastic Container Service Developer Guide</i>. After you created your unmanaged compute environment,
+ *       you can use the <a>DescribeComputeEnvironments</a> operation to find the Amazon ECS
+ *       cluster that's associated with it. Then, launch your container instances into that Amazon ECS
+ *       cluster. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_container_instance.html">Launching an Amazon ECS container
+ *         instance</a> in the <i>Amazon Elastic Container Service Developer Guide</i>.</p>
  *          <note>
- *             <p>To create a compute environment that uses EKS resources, the caller must have permissions to call
- *     <code>eks:DescribeCluster</code>.</p>
+ *             <p>To create a compute environment that uses EKS resources, the caller must have
+ *         permissions to call <code>eks:DescribeCluster</code>.</p>
  *          </note>
  *          <note>
- *             <p>Batch doesn't automatically upgrade the AMIs in a compute environment after it's created. For example, it
- *     also doesn't update the AMIs in your compute environment when a newer version of the Amazon ECS optimized AMI is
- *     available. You're responsible for the management of the guest operating system. This includes any updates and
- *     security patches. You're also responsible for any additional application software or utilities that you install on
- *     the compute resources. There are two ways to use a new AMI for your Batch jobs. The original method is to complete
- *     these steps:</p>
+ *             <p>Batch doesn't automatically upgrade the AMIs in a compute environment after it's
+ *         created. For example, it also doesn't update the AMIs in your compute environment when a
+ *         newer version of the Amazon ECS optimized AMI is available. You're responsible for the management
+ *         of the guest operating system. This includes any updates and security patches. You're also
+ *         responsible for any additional application software or utilities that you install on the
+ *         compute resources. There are two ways to use a new AMI for your Batch jobs. The original
+ *         method is to complete these steps:</p>
  *             <ol>
  *                <li>
  *                   <p>Create a new compute environment with the new AMI.</p>
@@ -69,17 +76,19 @@ declare const CreateComputeEnvironmentCommand_base: {
  *                   <p>Delete the earlier compute environment.</p>
  *                </li>
  *             </ol>
- *             <p>In April 2022, Batch added enhanced support for updating compute environments. For more information, see
- *      <a href="https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html">Updating compute
- *      environments</a>. To use the enhanced updating of compute environments to update AMIs, follow these
- *     rules:</p>
+ *             <p>In April 2022, Batch added enhanced support for updating compute environments. For
+ *         more information, see <a href="https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html">Updating compute environments</a>.
+ *         To use the enhanced updating of compute environments to update AMIs, follow these
+ *         rules:</p>
  *             <ul>
  *                <li>
- *                   <p>Either don't set the service role (<code>serviceRole</code>) parameter or set it to the <b>AWSBatchServiceRole</b> service-linked role.</p>
+ *                   <p>Either don't set the service role (<code>serviceRole</code>) parameter or set it to
+ *             the <b>AWSBatchServiceRole</b> service-linked role.</p>
  *                </li>
  *                <li>
- *                   <p>Set the allocation strategy (<code>allocationStrategy</code>) parameter to <code>BEST_FIT_PROGRESSIVE</code>,
- *         <code>SPOT_CAPACITY_OPTIMIZED</code>, or <code>SPOT_PRICE_CAPACITY_OPTIMIZED</code>.</p>
+ *                   <p>Set the allocation strategy (<code>allocationStrategy</code>) parameter to
+ *               <code>BEST_FIT_PROGRESSIVE</code>, <code>SPOT_CAPACITY_OPTIMIZED</code>, or
+ *               <code>SPOT_PRICE_CAPACITY_OPTIMIZED</code>.</p>
  *                </li>
  *                <li>
  *                   <p>Set the update to latest image version (<code>updateToLatestImageVersion</code>)
@@ -90,24 +99,29 @@ declare const CreateComputeEnvironmentCommand_base: {
  *             environment.</p>
  *                </li>
  *                <li>
- *                   <p>Don't specify an AMI ID in <code>imageId</code>, <code>imageIdOverride</code> (in <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_Ec2Configuration.html">
+ *                   <p>Don't specify an AMI ID in <code>imageId</code>, <code>imageIdOverride</code> (in
+ *               <a href="https://docs.aws.amazon.com/batch/latest/APIReference/API_Ec2Configuration.html">
  *                         <code>ec2Configuration</code>
- *                      </a>), or in the launch
- *        template (<code>launchTemplate</code>). In that case, Batch selects the latest Amazon ECS optimized AMI that's
- *        supported by Batch at the time the infrastructure update is initiated. Alternatively, you can specify the AMI ID
- *       in the <code>imageId</code> or <code>imageIdOverride</code> parameters, or the launch template identified by the
- *       <code>LaunchTemplate</code> properties. Changing any of these properties starts an infrastructure update. If the
- *       AMI ID is specified in the launch template, it can't be replaced by specifying an AMI ID in either the
- *       <code>imageId</code> or <code>imageIdOverride</code> parameters. It can only be replaced by specifying a different
- *       launch template, or if the launch template version is set to <code>$Default</code> or <code>$Latest</code>, by
- *       setting either a new default version for the launch template (if <code>$Default</code>) or by adding a new version
- *       to the launch template (if <code>$Latest</code>).</p>
+ *                      </a>), or in the launch template
+ *               (<code>launchTemplate</code>). In that case, Batch selects the latest Amazon ECS
+ *             optimized AMI that's supported by Batch at the time the infrastructure update is
+ *             initiated. Alternatively, you can specify the AMI ID in the <code>imageId</code> or
+ *               <code>imageIdOverride</code> parameters, or the launch template identified by the
+ *               <code>LaunchTemplate</code> properties. Changing any of these properties starts an
+ *             infrastructure update. If the AMI ID is specified in the launch template, it can't be
+ *             replaced by specifying an AMI ID in either the <code>imageId</code> or
+ *               <code>imageIdOverride</code> parameters. It can only be replaced by specifying a
+ *             different launch template, or if the launch template version is set to
+ *               <code>$Default</code> or <code>$Latest</code>, by setting either a new default version
+ *             for the launch template (if <code>$Default</code>) or by adding a new version to the
+ *             launch template (if <code>$Latest</code>).</p>
  *                </li>
  *             </ul>
- *             <p>If these rules are followed, any update that starts an infrastructure update causes the AMI ID to be
- *     re-selected. If the <code>version</code> setting in the launch template (<code>launchTemplate</code>) is set to
- *     <code>$Latest</code> or <code>$Default</code>, the latest or default version of the launch template is evaluated up
- *     at the time of the infrastructure update, even if the <code>launchTemplate</code> wasn't updated.</p>
+ *             <p>If these rules are followed, any update that starts an infrastructure update causes the
+ *         AMI ID to be re-selected. If the <code>version</code> setting in the launch template
+ *           (<code>launchTemplate</code>) is set to <code>$Latest</code> or <code>$Default</code>, the
+ *         latest or default version of the launch template is evaluated up at the time of the
+ *         infrastructure update, even if the <code>launchTemplate</code> wasn't updated.</p>
  *          </note>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

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

@@ -26,12 +26,13 @@ declare const CreateJobQueueCommand_base: {
 };
 /**
  * @public
- * <p>Creates an Batch job queue. When you create a job queue, you associate one or more compute environments to the
- *    queue and assign an order of preference for the compute environments.</p>
- *          <p>You also set a priority to the job queue that determines the order that the Batch scheduler places jobs onto
- *    its associated compute environments. For example, if a compute environment is associated with more than one job
- *    queue, the job queue with a higher priority is given preference for scheduling jobs to that compute
- *    environment.</p>
+ * <p>Creates an Batch job queue. When you create a job queue, you associate one or more
+ *       compute environments to the queue and assign an order of preference for the compute
+ *       environments.</p>
+ *          <p>You also set a priority to the job queue that determines the order that the Batch
+ *       scheduler places jobs onto its associated compute environments. For example, if a compute
+ *       environment is associated with more than one job queue, the job queue with a higher priority
+ *       is given preference for scheduling jobs to that compute environment.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -27,9 +27,12 @@ declare const DeleteComputeEnvironmentCommand_base: {
 /**
  * @public
  * <p>Deletes an Batch compute environment.</p>
- *          <p>Before you can delete a compute environment, you must set its state to <code>DISABLED</code> with the <a>UpdateComputeEnvironment</a> API operation and disassociate it from any job queues with the <a>UpdateJobQueue</a> API operation. Compute environments that use Fargate resources must terminate all
- *    active jobs on that compute environment before deleting the compute environment. If this isn't done, the compute
- *    environment enters an invalid state.</p>
+ *          <p>Before you can delete a compute environment, you must set its state to
+ *         <code>DISABLED</code> with the <a>UpdateComputeEnvironment</a> API operation and
+ *       disassociate it from any job queues with the <a>UpdateJobQueue</a> API operation.
+ *       Compute environments that use Fargate resources must terminate all active jobs on that
+ *       compute environment before deleting the compute environment. If this isn't done, the compute
+ *       environment enters an invalid state.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -26,10 +26,12 @@ declare const DeleteJobQueueCommand_base: {
 };
 /**
  * @public
- * <p>Deletes the specified job queue. You must first disable submissions for a queue with the <a>UpdateJobQueue</a> operation. All jobs in the queue are eventually terminated when you delete a job queue.
- *    The jobs are terminated at a rate of about 16 jobs each second.</p>
+ * <p>Deletes the specified job queue. You must first disable submissions for a queue with the
+ *         <a>UpdateJobQueue</a> operation. All jobs in the queue are eventually terminated
+ *       when you delete a job queue. The jobs are terminated at a rate of about 16 jobs each
+ *       second.</p>
  *          <p>It's not necessary to disassociate compute environments from a queue before submitting a
- *     <code>DeleteJobQueue</code> request.</p>
+ *         <code>DeleteJobQueue</code> request.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -26,7 +26,8 @@ declare const DeregisterJobDefinitionCommand_base: {
 };
 /**
  * @public
- * <p>Deregisters an Batch job definition. Job definitions are permanently deleted after 180 days.</p>
+ * <p>Deregisters an Batch job definition. Job definitions are permanently deleted after 180
+ *       days.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -27,9 +27,9 @@ declare const DescribeComputeEnvironmentsCommand_base: {
 /**
  * @public
  * <p>Describes one or more of your compute environments.</p>
- *          <p>If you're using an unmanaged compute environment, you can use the <code>DescribeComputeEnvironment</code>
- *    operation to determine the <code>ecsClusterArn</code> that you launch your Amazon ECS container instances
- *    into.</p>
+ *          <p>If you're using an unmanaged compute environment, you can use the
+ *         <code>DescribeComputeEnvironment</code> operation to determine the
+ *         <code>ecsClusterArn</code> that you launch your Amazon ECS container instances into.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript