@aws-sdk/client-batch 3.194.0 → 3.195.0

package/dist-es/protocols/Aws_restJson1.js

@@ -35,6 +35,9 @@ export const serializeAws_restJson1CreateComputeEnvironmentCommand = async (inpu
         ...(input.computeResources != null && {
             computeResources: serializeAws_restJson1ComputeResource(input.computeResources, context),
         }),
+        ...(input.eksConfiguration != null && {
+            eksConfiguration: serializeAws_restJson1EksConfiguration(input.eksConfiguration, context),
+        }),
         ...(input.serviceRole != null && { serviceRole: input.serviceRole }),
         ...(input.state != null && { state: input.state }),
         ...(input.tags != null && { tags: serializeAws_restJson1TagrisTagsMap(input.tags, context) }),
@@ -368,6 +371,9 @@ export const serializeAws_restJson1RegisterJobDefinitionCommand = async (input,
         ...(input.containerProperties != null && {
             containerProperties: serializeAws_restJson1ContainerProperties(input.containerProperties, context),
         }),
+        ...(input.eksProperties != null && {
+            eksProperties: serializeAws_restJson1EksProperties(input.eksProperties, context),
+        }),
         ...(input.jobDefinitionName != null && { jobDefinitionName: input.jobDefinitionName }),
         ...(input.nodeProperties != null && {
             nodeProperties: serializeAws_restJson1NodeProperties(input.nodeProperties, context),
@@ -410,6 +416,9 @@ export const serializeAws_restJson1SubmitJobCommand = async (input, context) =>
             containerOverrides: serializeAws_restJson1ContainerOverrides(input.containerOverrides, context),
         }),
         ...(input.dependsOn != null && { dependsOn: serializeAws_restJson1JobDependencyList(input.dependsOn, context) }),
+        ...(input.eksPropertiesOverride != null && {
+            eksPropertiesOverride: serializeAws_restJson1EksPropertiesOverride(input.eksPropertiesOverride, context),
+        }),
         ...(input.jobDefinition != null && { jobDefinition: input.jobDefinition }),
         ...(input.jobName != null && { jobName: input.jobName }),
         ...(input.jobQueue != null && { jobQueue: input.jobQueue }),
@@ -1632,6 +1641,7 @@ const serializeAws_restJson1DevicesList = (input, context) => {
 const serializeAws_restJson1Ec2Configuration = (input, context) => {
     return {
         ...(input.imageIdOverride != null && { imageIdOverride: input.imageIdOverride }),
+        ...(input.imageKubernetesVersion != null && { imageKubernetesVersion: input.imageKubernetesVersion }),
         ...(input.imageType != null && { imageType: input.imageType }),
     };
 };
@@ -1659,6 +1669,182 @@ const serializeAws_restJson1EFSVolumeConfiguration = (input, context) => {
         ...(input.transitEncryptionPort != null && { transitEncryptionPort: input.transitEncryptionPort }),
     };
 };
+const serializeAws_restJson1EksConfiguration = (input, context) => {
+    return {
+        ...(input.eksClusterArn != null && { eksClusterArn: input.eksClusterArn }),
+        ...(input.kubernetesNamespace != null && { kubernetesNamespace: input.kubernetesNamespace }),
+    };
+};
+const serializeAws_restJson1EksContainer = (input, context) => {
+    return {
+        ...(input.args != null && { args: serializeAws_restJson1StringList(input.args, context) }),
+        ...(input.command != null && { command: serializeAws_restJson1StringList(input.command, context) }),
+        ...(input.env != null && { env: serializeAws_restJson1EksContainerEnvironmentVariables(input.env, context) }),
+        ...(input.image != null && { image: input.image }),
+        ...(input.imagePullPolicy != null && { imagePullPolicy: input.imagePullPolicy }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.resources != null && {
+            resources: serializeAws_restJson1EksContainerResourceRequirements(input.resources, context),
+        }),
+        ...(input.securityContext != null && {
+            securityContext: serializeAws_restJson1EksContainerSecurityContext(input.securityContext, context),
+        }),
+        ...(input.volumeMounts != null && {
+            volumeMounts: serializeAws_restJson1EksContainerVolumeMounts(input.volumeMounts, context),
+        }),
+    };
+};
+const serializeAws_restJson1EksContainerEnvironmentVariable = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+        ...(input.value != null && { value: input.value }),
+    };
+};
+const serializeAws_restJson1EksContainerEnvironmentVariables = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1EksContainerEnvironmentVariable(entry, context);
+    });
+};
+const serializeAws_restJson1EksContainerOverride = (input, context) => {
+    return {
+        ...(input.args != null && { args: serializeAws_restJson1StringList(input.args, context) }),
+        ...(input.command != null && { command: serializeAws_restJson1StringList(input.command, context) }),
+        ...(input.env != null && { env: serializeAws_restJson1EksContainerEnvironmentVariables(input.env, context) }),
+        ...(input.image != null && { image: input.image }),
+        ...(input.resources != null && {
+            resources: serializeAws_restJson1EksContainerResourceRequirements(input.resources, context),
+        }),
+    };
+};
+const serializeAws_restJson1EksContainerOverrideList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1EksContainerOverride(entry, context);
+    });
+};
+const serializeAws_restJson1EksContainerResourceRequirements = (input, context) => {
+    return {
+        ...(input.limits != null && { limits: serializeAws_restJson1EksLimits(input.limits, context) }),
+        ...(input.requests != null && { requests: serializeAws_restJson1EksRequests(input.requests, context) }),
+    };
+};
+const serializeAws_restJson1EksContainers = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1EksContainer(entry, context);
+    });
+};
+const serializeAws_restJson1EksContainerSecurityContext = (input, context) => {
+    return {
+        ...(input.privileged != null && { privileged: input.privileged }),
+        ...(input.readOnlyRootFilesystem != null && { readOnlyRootFilesystem: input.readOnlyRootFilesystem }),
+        ...(input.runAsGroup != null && { runAsGroup: input.runAsGroup }),
+        ...(input.runAsNonRoot != null && { runAsNonRoot: input.runAsNonRoot }),
+        ...(input.runAsUser != null && { runAsUser: input.runAsUser }),
+    };
+};
+const serializeAws_restJson1EksContainerVolumeMount = (input, context) => {
+    return {
+        ...(input.mountPath != null && { mountPath: input.mountPath }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.readOnly != null && { readOnly: input.readOnly }),
+    };
+};
+const serializeAws_restJson1EksContainerVolumeMounts = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1EksContainerVolumeMount(entry, context);
+    });
+};
+const serializeAws_restJson1EksEmptyDir = (input, context) => {
+    return {
+        ...(input.medium != null && { medium: input.medium }),
+        ...(input.sizeLimit != null && { sizeLimit: input.sizeLimit }),
+    };
+};
+const serializeAws_restJson1EksHostPath = (input, context) => {
+    return {
+        ...(input.path != null && { path: input.path }),
+    };
+};
+const serializeAws_restJson1EksLimits = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1EksPodProperties = (input, context) => {
+    return {
+        ...(input.containers != null && { containers: serializeAws_restJson1EksContainers(input.containers, context) }),
+        ...(input.dnsPolicy != null && { dnsPolicy: input.dnsPolicy }),
+        ...(input.hostNetwork != null && { hostNetwork: input.hostNetwork }),
+        ...(input.serviceAccountName != null && { serviceAccountName: input.serviceAccountName }),
+        ...(input.volumes != null && { volumes: serializeAws_restJson1EksVolumes(input.volumes, context) }),
+    };
+};
+const serializeAws_restJson1EksPodPropertiesOverride = (input, context) => {
+    return {
+        ...(input.containers != null && {
+            containers: serializeAws_restJson1EksContainerOverrideList(input.containers, context),
+        }),
+    };
+};
+const serializeAws_restJson1EksProperties = (input, context) => {
+    return {
+        ...(input.podProperties != null && {
+            podProperties: serializeAws_restJson1EksPodProperties(input.podProperties, context),
+        }),
+    };
+};
+const serializeAws_restJson1EksPropertiesOverride = (input, context) => {
+    return {
+        ...(input.podProperties != null && {
+            podProperties: serializeAws_restJson1EksPodPropertiesOverride(input.podProperties, context),
+        }),
+    };
+};
+const serializeAws_restJson1EksRequests = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: value,
+        };
+    }, {});
+};
+const serializeAws_restJson1EksSecret = (input, context) => {
+    return {
+        ...(input.optional != null && { optional: input.optional }),
+        ...(input.secretName != null && { secretName: input.secretName }),
+    };
+};
+const serializeAws_restJson1EksVolume = (input, context) => {
+    return {
+        ...(input.emptyDir != null && { emptyDir: serializeAws_restJson1EksEmptyDir(input.emptyDir, context) }),
+        ...(input.hostPath != null && { hostPath: serializeAws_restJson1EksHostPath(input.hostPath, context) }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.secret != null && { secret: serializeAws_restJson1EksSecret(input.secret, context) }),
+    };
+};
+const serializeAws_restJson1EksVolumes = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1EksVolume(entry, context);
+    });
+};
 const serializeAws_restJson1EnvironmentVariables = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -2046,7 +2232,11 @@ const deserializeAws_restJson1ComputeEnvironmentDetail = (output, context) => {
         computeResources: output.computeResources != null
             ? deserializeAws_restJson1ComputeResource(output.computeResources, context)
             : undefined,
+        containerOrchestrationType: __expectString(output.containerOrchestrationType),
         ecsClusterArn: __expectString(output.ecsClusterArn),
+        eksConfiguration: output.eksConfiguration != null
+            ? deserializeAws_restJson1EksConfiguration(output.eksConfiguration, context)
+            : undefined,
         serviceRole: __expectString(output.serviceRole),
         state: __expectString(output.state),
         status: __expectString(output.status),
@@ -2055,6 +2245,7 @@ const deserializeAws_restJson1ComputeEnvironmentDetail = (output, context) => {
         type: __expectString(output.type),
         unmanagedvCpus: __expectInt32(output.unmanagedvCpus),
         updatePolicy: output.updatePolicy != null ? deserializeAws_restJson1UpdatePolicy(output.updatePolicy, context) : undefined,
+        uuid: __expectString(output.uuid),
     };
 };
 const deserializeAws_restJson1ComputeEnvironmentDetailList = (output, context) => {
@@ -2232,6 +2423,7 @@ const deserializeAws_restJson1DevicesList = (output, context) => {
 const deserializeAws_restJson1Ec2Configuration = (output, context) => {
     return {
         imageIdOverride: __expectString(output.imageIdOverride),
+        imageKubernetesVersion: __expectString(output.imageKubernetesVersion),
         imageType: __expectString(output.imageType),
     };
 };
@@ -2263,6 +2455,256 @@ const deserializeAws_restJson1EFSVolumeConfiguration = (output, context) => {
         transitEncryptionPort: __expectInt32(output.transitEncryptionPort),
     };
 };
+const deserializeAws_restJson1EksAttemptContainerDetail = (output, context) => {
+    return {
+        exitCode: __expectInt32(output.exitCode),
+        reason: __expectString(output.reason),
+    };
+};
+const deserializeAws_restJson1EksAttemptContainerDetails = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksAttemptContainerDetail(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksAttemptDetail = (output, context) => {
+    return {
+        containers: output.containers != null
+            ? deserializeAws_restJson1EksAttemptContainerDetails(output.containers, context)
+            : undefined,
+        nodeName: __expectString(output.nodeName),
+        podName: __expectString(output.podName),
+        startedAt: __expectLong(output.startedAt),
+        statusReason: __expectString(output.statusReason),
+        stoppedAt: __expectLong(output.stoppedAt),
+    };
+};
+const deserializeAws_restJson1EksAttemptDetails = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksAttemptDetail(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksConfiguration = (output, context) => {
+    return {
+        eksClusterArn: __expectString(output.eksClusterArn),
+        kubernetesNamespace: __expectString(output.kubernetesNamespace),
+    };
+};
+const deserializeAws_restJson1EksContainer = (output, context) => {
+    return {
+        args: output.args != null ? deserializeAws_restJson1StringList(output.args, context) : undefined,
+        command: output.command != null ? deserializeAws_restJson1StringList(output.command, context) : undefined,
+        env: output.env != null ? deserializeAws_restJson1EksContainerEnvironmentVariables(output.env, context) : undefined,
+        image: __expectString(output.image),
+        imagePullPolicy: __expectString(output.imagePullPolicy),
+        name: __expectString(output.name),
+        resources: output.resources != null
+            ? deserializeAws_restJson1EksContainerResourceRequirements(output.resources, context)
+            : undefined,
+        securityContext: output.securityContext != null
+            ? deserializeAws_restJson1EksContainerSecurityContext(output.securityContext, context)
+            : undefined,
+        volumeMounts: output.volumeMounts != null
+            ? deserializeAws_restJson1EksContainerVolumeMounts(output.volumeMounts, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1EksContainerDetail = (output, context) => {
+    return {
+        args: output.args != null ? deserializeAws_restJson1StringList(output.args, context) : undefined,
+        command: output.command != null ? deserializeAws_restJson1StringList(output.command, context) : undefined,
+        env: output.env != null ? deserializeAws_restJson1EksContainerEnvironmentVariables(output.env, context) : undefined,
+        exitCode: __expectInt32(output.exitCode),
+        image: __expectString(output.image),
+        imagePullPolicy: __expectString(output.imagePullPolicy),
+        name: __expectString(output.name),
+        reason: __expectString(output.reason),
+        resources: output.resources != null
+            ? deserializeAws_restJson1EksContainerResourceRequirements(output.resources, context)
+            : undefined,
+        securityContext: output.securityContext != null
+            ? deserializeAws_restJson1EksContainerSecurityContext(output.securityContext, context)
+            : undefined,
+        volumeMounts: output.volumeMounts != null
+            ? deserializeAws_restJson1EksContainerVolumeMounts(output.volumeMounts, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1EksContainerDetails = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksContainerDetail(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksContainerEnvironmentVariable = (output, context) => {
+    return {
+        name: __expectString(output.name),
+        value: __expectString(output.value),
+    };
+};
+const deserializeAws_restJson1EksContainerEnvironmentVariables = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksContainerEnvironmentVariable(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksContainerResourceRequirements = (output, context) => {
+    return {
+        limits: output.limits != null ? deserializeAws_restJson1EksLimits(output.limits, context) : undefined,
+        requests: output.requests != null ? deserializeAws_restJson1EksRequests(output.requests, context) : undefined,
+    };
+};
+const deserializeAws_restJson1EksContainers = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksContainer(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksContainerSecurityContext = (output, context) => {
+    return {
+        privileged: __expectBoolean(output.privileged),
+        readOnlyRootFilesystem: __expectBoolean(output.readOnlyRootFilesystem),
+        runAsGroup: __expectLong(output.runAsGroup),
+        runAsNonRoot: __expectBoolean(output.runAsNonRoot),
+        runAsUser: __expectLong(output.runAsUser),
+    };
+};
+const deserializeAws_restJson1EksContainerVolumeMount = (output, context) => {
+    return {
+        mountPath: __expectString(output.mountPath),
+        name: __expectString(output.name),
+        readOnly: __expectBoolean(output.readOnly),
+    };
+};
+const deserializeAws_restJson1EksContainerVolumeMounts = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksContainerVolumeMount(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EksEmptyDir = (output, context) => {
+    return {
+        medium: __expectString(output.medium),
+        sizeLimit: __expectString(output.sizeLimit),
+    };
+};
+const deserializeAws_restJson1EksHostPath = (output, context) => {
+    return {
+        path: __expectString(output.path),
+    };
+};
+const deserializeAws_restJson1EksLimits = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: __expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1EksPodProperties = (output, context) => {
+    return {
+        containers: output.containers != null ? deserializeAws_restJson1EksContainers(output.containers, context) : undefined,
+        dnsPolicy: __expectString(output.dnsPolicy),
+        hostNetwork: __expectBoolean(output.hostNetwork),
+        serviceAccountName: __expectString(output.serviceAccountName),
+        volumes: output.volumes != null ? deserializeAws_restJson1EksVolumes(output.volumes, context) : undefined,
+    };
+};
+const deserializeAws_restJson1EksPodPropertiesDetail = (output, context) => {
+    return {
+        containers: output.containers != null ? deserializeAws_restJson1EksContainerDetails(output.containers, context) : undefined,
+        dnsPolicy: __expectString(output.dnsPolicy),
+        hostNetwork: __expectBoolean(output.hostNetwork),
+        nodeName: __expectString(output.nodeName),
+        podName: __expectString(output.podName),
+        serviceAccountName: __expectString(output.serviceAccountName),
+        volumes: output.volumes != null ? deserializeAws_restJson1EksVolumes(output.volumes, context) : undefined,
+    };
+};
+const deserializeAws_restJson1EksProperties = (output, context) => {
+    return {
+        podProperties: output.podProperties != null
+            ? deserializeAws_restJson1EksPodProperties(output.podProperties, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1EksPropertiesDetail = (output, context) => {
+    return {
+        podProperties: output.podProperties != null
+            ? deserializeAws_restJson1EksPodPropertiesDetail(output.podProperties, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1EksRequests = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        return {
+            ...acc,
+            [key]: __expectString(value),
+        };
+    }, {});
+};
+const deserializeAws_restJson1EksSecret = (output, context) => {
+    return {
+        optional: __expectBoolean(output.optional),
+        secretName: __expectString(output.secretName),
+    };
+};
+const deserializeAws_restJson1EksVolume = (output, context) => {
+    return {
+        emptyDir: output.emptyDir != null ? deserializeAws_restJson1EksEmptyDir(output.emptyDir, context) : undefined,
+        hostPath: output.hostPath != null ? deserializeAws_restJson1EksHostPath(output.hostPath, context) : undefined,
+        name: __expectString(output.name),
+        secret: output.secret != null ? deserializeAws_restJson1EksSecret(output.secret, context) : undefined,
+    };
+};
+const deserializeAws_restJson1EksVolumes = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1EksVolume(entry, context);
+    });
+    return retVal;
+};
 const deserializeAws_restJson1EnvironmentVariables = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -2314,9 +2756,11 @@ const deserializeAws_restJson1Host = (output, context) => {
 };
 const deserializeAws_restJson1JobDefinition = (output, context) => {
     return {
+        containerOrchestrationType: __expectString(output.containerOrchestrationType),
         containerProperties: output.containerProperties != null
             ? deserializeAws_restJson1ContainerProperties(output.containerProperties, context)
             : undefined,
+        eksProperties: output.eksProperties != null ? deserializeAws_restJson1EksProperties(output.eksProperties, context) : undefined,
         jobDefinitionArn: __expectString(output.jobDefinitionArn),
         jobDefinitionName: __expectString(output.jobDefinitionName),
         nodeProperties: output.nodeProperties != null
@@ -2373,6 +2817,10 @@ const deserializeAws_restJson1JobDetail = (output, context) => {
         container: output.container != null ? deserializeAws_restJson1ContainerDetail(output.container, context) : undefined,
         createdAt: __expectLong(output.createdAt),
         dependsOn: output.dependsOn != null ? deserializeAws_restJson1JobDependencyList(output.dependsOn, context) : undefined,
+        eksAttempts: output.eksAttempts != null ? deserializeAws_restJson1EksAttemptDetails(output.eksAttempts, context) : undefined,
+        eksProperties: output.eksProperties != null
+            ? deserializeAws_restJson1EksPropertiesDetail(output.eksProperties, context)
+            : undefined,
         jobArn: __expectString(output.jobArn),
         jobDefinition: __expectString(output.jobDefinition),
         jobId: __expectString(output.jobId),

package/dist-es/runtimeConfig.shared.js

@@ -1,10 +1,10 @@
 import { parseUrl } from "@aws-sdk/url-parser";
-import { defaultRegionInfoProvider } from "./endpoints";
+import { defaultEndpointResolver } from "./endpoint/endpointResolver";
 export const getRuntimeConfig = (config) => ({
     apiVersion: "2016-08-10",
     disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
     logger: config?.logger ?? {},
-    regionInfoProvider: config?.regionInfoProvider ?? defaultRegionInfoProvider,
     serviceId: config?.serviceId ?? "Batch",
     urlParser: config?.urlParser ?? parseUrl,
 });

package/dist-types/Batch.d.ts

@@ -28,21 +28,21 @@ import { UpdateSchedulingPolicyCommandInput, UpdateSchedulingPolicyCommandOutput
  * <fullname>Batch</fullname>
  *          <p>Using Batch, you can run batch computing workloads on the Amazon Web Services Cloud. Batch computing is a common means for
  *    developers, scientists, and engineers to access large amounts of compute resources. Batch uses the advantages of
- *    this computing workload to remove the undifferentiated heavy lifting of configuring and managing required
- *    infrastructure. At the same time, it also adopts a familiar batch computing software approach. Given these
- *    advantages, Batch can help you to efficiently provision resources in response to jobs submitted, thus effectively
- *    helping you to eliminate capacity constraints, reduce compute costs, and deliver your results more quickly.</p>
+ *    the batch computing to remove the undifferentiated heavy lifting of configuring and managing required infrastructure.
+ *    At the same time, it also adopts a familiar batch computing software approach. You can use Batch to efficiently
+ *    provision resources d, and work toward eliminating capacity constraints, reducing your overall compute costs, and
+ *    delivering results more quickly.</p>
  *          <p>As a fully managed service, Batch can run batch computing workloads of any scale. Batch automatically
  *    provisions compute resources and optimizes workload distribution based on the quantity and scale of your specific
  *    workloads. With Batch, there's no need to install or manage batch computing software. This means that you can focus
- *    your time and energy on analyzing results and solving your specific problems.</p>
+ *    on analyzing results and solving your specific problems instead.</p>
  */
 export declare class Batch extends BatchClient {
     /**
      * <p>Cancels a job in an Batch job queue. Jobs that are in the <code>SUBMITTED</code>, <code>PENDING</code>, or
-     *     <code>RUNNABLE</code> state are canceled. Jobs that have progressed to <code>STARTING</code> or <code>RUNNING</code>
-     *    aren't canceled, but the API operation still succeeds, even if no job is canceled. These jobs must be terminated with
-     *    the <a>TerminateJob</a> operation.</p>
+     *    <code>RUNNABLE</code> state are canceled. Jobs that progressed to the <code>STARTING</code> or <code>RUNNING</code>
+     *    state aren't canceled. However, the API operation still succeeds, even if no job is canceled. These jobs must be
+     *    terminated with the <a>TerminateJob</a> operation.</p>
      */
     cancelJob(args: CancelJobCommandInput, options?: __HttpHandlerOptions): Promise<CancelJobCommandOutput>;
     cancelJob(args: CancelJobCommandInput, cb: (err: any, data?: CancelJobCommandOutput) => void): void;
@@ -60,12 +60,12 @@ export declare class Batch extends BatchClient {
      *          <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 a lot of 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
+     *          <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>
+     *    <i>Amazon Elastic Container Service Developer Guide</i>.</p>
      *          <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
@@ -93,7 +93,7 @@ export declare class Batch extends BatchClient {
      *     rules:</p>
      *             <ul>
      *                <li>
-     *                   <p>Either do not 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>
@@ -104,24 +104,24 @@ export declare class Batch extends BatchClient {
      *        <code>true</code>.</p>
      *                </li>
      *                <li>
-     *                   <p>Do not 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 will select the latest Amazon ECS optimized AMI 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 will trigger an infrastructure update. If the AMI ID is specified in the launch template, it can not 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 triggers an infrastructure update will cause the AMI ID to be
+     *             <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 will be
-     *     evaluated up at the time of the infrastructure update, even if the <code>launchTemplate</code> was not
-     *     updated.</p>
+     *     <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>
      */
     createComputeEnvironment(args: CreateComputeEnvironmentCommandInput, options?: __HttpHandlerOptions): Promise<CreateComputeEnvironmentCommandOutput>;
@@ -237,7 +237,7 @@ export declare class Batch extends BatchClient {
     listSchedulingPolicies(args: ListSchedulingPoliciesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListSchedulingPoliciesCommandOutput) => void): void;
     /**
      * <p>Lists the tags for an Batch resource. Batch resources that support tags are compute environments, jobs, job definitions, job queues,
-     *  and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
+     *  and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP) jobs aren't supported.</p>
      */
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
@@ -270,7 +270,7 @@ export declare class Batch extends BatchClient {
      * <p>Associates the specified tags to a resource with the specified <code>resourceArn</code>. If existing tags on a
      *    resource aren't specified in the request parameters, they aren't changed. When a resource is deleted, the tags that
      *    are associated with that resource are deleted as well. Batch resources that support tags are compute environments, jobs, job definitions, job queues,
-     *  and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP) jobs are not supported.</p>
+     *  and scheduling policies. ARNs for child jobs of array and multi-node parallel (MNP) jobs aren't supported.</p>
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;