@aws-sdk/client-batch 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2242 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./BatchClient"), exports);
-tslib_1.__exportStar(require("./Batch"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var BatchServiceException_1 = require("./models/BatchServiceException");
-Object.defineProperty(exports, "BatchServiceException", { enumerable: true, get: function () { return BatchServiceException_1.BatchServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ArrayJobDependency: () => ArrayJobDependency,
+  AssignPublicIp: () => AssignPublicIp,
+  Batch: () => Batch,
+  BatchClient: () => BatchClient,
+  BatchServiceException: () => BatchServiceException,
+  CEState: () => CEState,
+  CEStatus: () => CEStatus,
+  CEType: () => CEType,
+  CRAllocationStrategy: () => CRAllocationStrategy,
+  CRType: () => CRType,
+  CRUpdateAllocationStrategy: () => CRUpdateAllocationStrategy,
+  CancelJobCommand: () => CancelJobCommand,
+  ClientException: () => ClientException,
+  CreateComputeEnvironmentCommand: () => CreateComputeEnvironmentCommand,
+  CreateJobQueueCommand: () => CreateJobQueueCommand,
+  CreateSchedulingPolicyCommand: () => CreateSchedulingPolicyCommand,
+  DeleteComputeEnvironmentCommand: () => DeleteComputeEnvironmentCommand,
+  DeleteJobQueueCommand: () => DeleteJobQueueCommand,
+  DeleteSchedulingPolicyCommand: () => DeleteSchedulingPolicyCommand,
+  DeregisterJobDefinitionCommand: () => DeregisterJobDefinitionCommand,
+  DescribeComputeEnvironmentsCommand: () => DescribeComputeEnvironmentsCommand,
+  DescribeJobDefinitionsCommand: () => DescribeJobDefinitionsCommand,
+  DescribeJobQueuesCommand: () => DescribeJobQueuesCommand,
+  DescribeJobsCommand: () => DescribeJobsCommand,
+  DescribeSchedulingPoliciesCommand: () => DescribeSchedulingPoliciesCommand,
+  DeviceCgroupPermission: () => DeviceCgroupPermission,
+  EFSAuthorizationConfigIAM: () => EFSAuthorizationConfigIAM,
+  EFSTransitEncryption: () => EFSTransitEncryption,
+  JQState: () => JQState,
+  JQStatus: () => JQStatus,
+  JobDefinitionType: () => JobDefinitionType,
+  JobStatus: () => JobStatus,
+  ListJobsCommand: () => ListJobsCommand,
+  ListSchedulingPoliciesCommand: () => ListSchedulingPoliciesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LogDriver: () => LogDriver,
+  OrchestrationType: () => OrchestrationType,
+  PlatformCapability: () => PlatformCapability,
+  RegisterJobDefinitionCommand: () => RegisterJobDefinitionCommand,
+  ResourceType: () => ResourceType,
+  RetryAction: () => RetryAction,
+  ServerException: () => ServerException,
+  SubmitJobCommand: () => SubmitJobCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TerminateJobCommand: () => TerminateJobCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateComputeEnvironmentCommand: () => UpdateComputeEnvironmentCommand,
+  UpdateJobQueueCommand: () => UpdateJobQueueCommand,
+  UpdateSchedulingPolicyCommand: () => UpdateSchedulingPolicyCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeComputeEnvironments: () => paginateDescribeComputeEnvironments,
+  paginateDescribeJobDefinitions: () => paginateDescribeJobDefinitions,
+  paginateDescribeJobQueues: () => paginateDescribeJobQueues,
+  paginateListJobs: () => paginateListJobs,
+  paginateListSchedulingPolicies: () => paginateListSchedulingPolicies
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/BatchClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "batch"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/BatchClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/BatchClient.ts
+var _BatchClient = class _BatchClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_BatchClient, "BatchClient");
+var BatchClient = _BatchClient;
+
+// src/Batch.ts
+
+
+// src/commands/CancelJobCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+
+// src/models/BatchServiceException.ts
+
+var _BatchServiceException = class _BatchServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _BatchServiceException.prototype);
+  }
+};
+__name(_BatchServiceException, "BatchServiceException");
+var BatchServiceException = _BatchServiceException;
+
+// src/models/models_0.ts
+var ArrayJobDependency = {
+  N_TO_N: "N_TO_N",
+  SEQUENTIAL: "SEQUENTIAL"
+};
+var AssignPublicIp = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var _ClientException = class _ClientException extends BatchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClientException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClientException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClientException.prototype);
+  }
+};
+__name(_ClientException, "ClientException");
+var ClientException = _ClientException;
+var _ServerException = class _ServerException extends BatchServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServerException.prototype);
+  }
+};
+__name(_ServerException, "ServerException");
+var ServerException = _ServerException;
+var CRAllocationStrategy = {
+  BEST_FIT: "BEST_FIT",
+  BEST_FIT_PROGRESSIVE: "BEST_FIT_PROGRESSIVE",
+  SPOT_CAPACITY_OPTIMIZED: "SPOT_CAPACITY_OPTIMIZED",
+  SPOT_PRICE_CAPACITY_OPTIMIZED: "SPOT_PRICE_CAPACITY_OPTIMIZED"
+};
+var CRType = {
+  EC2: "EC2",
+  FARGATE: "FARGATE",
+  FARGATE_SPOT: "FARGATE_SPOT",
+  SPOT: "SPOT"
+};
+var CEState = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var CEType = {
+  MANAGED: "MANAGED",
+  UNMANAGED: "UNMANAGED"
+};
+var JQState = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var OrchestrationType = {
+  ECS: "ECS",
+  EKS: "EKS"
+};
+var CEStatus = {
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETING: "DELETING",
+  INVALID: "INVALID",
+  UPDATING: "UPDATING",
+  VALID: "VALID"
+};
+var DeviceCgroupPermission = {
+  MKNOD: "MKNOD",
+  READ: "READ",
+  WRITE: "WRITE"
+};
+var LogDriver = {
+  AWSLOGS: "awslogs",
+  FLUENTD: "fluentd",
+  GELF: "gelf",
+  JOURNALD: "journald",
+  JSON_FILE: "json-file",
+  SPLUNK: "splunk",
+  SYSLOG: "syslog"
+};
+var ResourceType = {
+  GPU: "GPU",
+  MEMORY: "MEMORY",
+  VCPU: "VCPU"
+};
+var EFSAuthorizationConfigIAM = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var EFSTransitEncryption = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var PlatformCapability = {
+  EC2: "EC2",
+  FARGATE: "FARGATE"
+};
+var RetryAction = {
+  EXIT: "EXIT",
+  RETRY: "RETRY"
+};
+var JQStatus = {
+  CREATING: "CREATING",
+  DELETED: "DELETED",
+  DELETING: "DELETING",
+  INVALID: "INVALID",
+  UPDATING: "UPDATING",
+  VALID: "VALID"
+};
+var JobStatus = {
+  FAILED: "FAILED",
+  PENDING: "PENDING",
+  RUNNABLE: "RUNNABLE",
+  RUNNING: "RUNNING",
+  STARTING: "STARTING",
+  SUBMITTED: "SUBMITTED",
+  SUCCEEDED: "SUCCEEDED"
+};
+var JobDefinitionType = {
+  Container: "container",
+  Multinode: "multinode"
+};
+var CRUpdateAllocationStrategy = {
+  BEST_FIT_PROGRESSIVE: "BEST_FIT_PROGRESSIVE",
+  SPOT_CAPACITY_OPTIMIZED: "SPOT_CAPACITY_OPTIMIZED",
+  SPOT_PRICE_CAPACITY_OPTIMIZED: "SPOT_PRICE_CAPACITY_OPTIMIZED"
+};
+
+// src/protocols/Aws_restJson1.ts
+var se_CancelJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/canceljob");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobId: [],
+      reason: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CancelJobCommand");
+var se_CreateComputeEnvironmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/createcomputeenvironment");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironmentName: [],
+      computeResources: (_) => (0, import_smithy_client._json)(_),
+      eksConfiguration: (_) => (0, import_smithy_client._json)(_),
+      serviceRole: [],
+      state: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      type: [],
+      unmanagedvCpus: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateComputeEnvironmentCommand");
+var se_CreateJobQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/createjobqueue");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironmentOrder: (_) => (0, import_smithy_client._json)(_),
+      jobQueueName: [],
+      priority: [],
+      schedulingPolicyArn: [],
+      state: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateJobQueueCommand");
+var se_CreateSchedulingPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/createschedulingpolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      fairsharePolicy: (_) => se_FairsharePolicy(_, context),
+      name: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSchedulingPolicyCommand");
+var se_DeleteComputeEnvironmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/deletecomputeenvironment");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironment: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteComputeEnvironmentCommand");
+var se_DeleteJobQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/deletejobqueue");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobQueue: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteJobQueueCommand");
+var se_DeleteSchedulingPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/deleteschedulingpolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteSchedulingPolicyCommand");
+var se_DeregisterJobDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/deregisterjobdefinition");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobDefinition: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeregisterJobDefinitionCommand");
+var se_DescribeComputeEnvironmentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/describecomputeenvironments");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironments: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeComputeEnvironmentsCommand");
+var se_DescribeJobDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/describejobdefinitions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobDefinitionName: [],
+      jobDefinitions: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: [],
+      status: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeJobDefinitionsCommand");
+var se_DescribeJobQueuesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/describejobqueues");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobQueues: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeJobQueuesCommand");
+var se_DescribeJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/describejobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobs: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeJobsCommand");
+var se_DescribeSchedulingPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/describeschedulingpolicies");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arns: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DescribeSchedulingPoliciesCommand");
+var se_ListJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/listjobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arrayJobId: [],
+      filters: (_) => (0, import_smithy_client._json)(_),
+      jobQueue: [],
+      jobStatus: [],
+      maxResults: [],
+      multiNodeJobId: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListJobsCommand");
+var se_ListSchedulingPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/listschedulingpolicies");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListSchedulingPoliciesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_RegisterJobDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/registerjobdefinition");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      containerProperties: (_) => (0, import_smithy_client._json)(_),
+      eksProperties: (_) => (0, import_smithy_client._json)(_),
+      jobDefinitionName: [],
+      nodeProperties: (_) => (0, import_smithy_client._json)(_),
+      parameters: (_) => (0, import_smithy_client._json)(_),
+      platformCapabilities: (_) => (0, import_smithy_client._json)(_),
+      propagateTags: [],
+      retryStrategy: (_) => (0, import_smithy_client._json)(_),
+      schedulingPriority: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      timeout: (_) => (0, import_smithy_client._json)(_),
+      type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RegisterJobDefinitionCommand");
+var se_SubmitJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/submitjob");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arrayProperties: (_) => (0, import_smithy_client._json)(_),
+      containerOverrides: (_) => (0, import_smithy_client._json)(_),
+      dependsOn: (_) => (0, import_smithy_client._json)(_),
+      eksPropertiesOverride: (_) => (0, import_smithy_client._json)(_),
+      jobDefinition: [],
+      jobName: [],
+      jobQueue: [],
+      nodeOverrides: (_) => (0, import_smithy_client._json)(_),
+      parameters: (_) => (0, import_smithy_client._json)(_),
+      propagateTags: [],
+      retryStrategy: (_) => (0, import_smithy_client._json)(_),
+      schedulingPriorityOverride: [],
+      shareIdentifier: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      timeout: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SubmitJobCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_TerminateJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/terminatejob");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      jobId: [],
+      reason: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TerminateJobCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateComputeEnvironmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/updatecomputeenvironment");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironment: [],
+      computeResources: (_) => (0, import_smithy_client._json)(_),
+      serviceRole: [],
+      state: [],
+      unmanagedvCpus: [],
+      updatePolicy: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateComputeEnvironmentCommand");
+var se_UpdateJobQueueCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/updatejobqueue");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      computeEnvironmentOrder: (_) => (0, import_smithy_client._json)(_),
+      jobQueue: [],
+      priority: [],
+      schedulingPolicyArn: [],
+      state: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateJobQueueCommand");
+var se_UpdateSchedulingPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/updateschedulingpolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: [],
+      fairsharePolicy: (_) => se_FairsharePolicy(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateSchedulingPolicyCommand");
+var de_CancelJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CancelJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CancelJobCommand");
+var de_CancelJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CancelJobCommandError");
+var de_CreateComputeEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateComputeEnvironmentCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    computeEnvironmentArn: import_smithy_client.expectString,
+    computeEnvironmentName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateComputeEnvironmentCommand");
+var de_CreateComputeEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateComputeEnvironmentCommandError");
+var de_CreateJobQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateJobQueueCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobQueueArn: import_smithy_client.expectString,
+    jobQueueName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateJobQueueCommand");
+var de_CreateJobQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateJobQueueCommandError");
+var de_CreateSchedulingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateSchedulingPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    arn: import_smithy_client.expectString,
+    name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSchedulingPolicyCommand");
+var de_CreateSchedulingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSchedulingPolicyCommandError");
+var de_DeleteComputeEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteComputeEnvironmentCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteComputeEnvironmentCommand");
+var de_DeleteComputeEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteComputeEnvironmentCommandError");
+var de_DeleteJobQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteJobQueueCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteJobQueueCommand");
+var de_DeleteJobQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteJobQueueCommandError");
+var de_DeleteSchedulingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteSchedulingPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSchedulingPolicyCommand");
+var de_DeleteSchedulingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSchedulingPolicyCommandError");
+var de_DeregisterJobDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeregisterJobDefinitionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeregisterJobDefinitionCommand");
+var de_DeregisterJobDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeregisterJobDefinitionCommandError");
+var de_DescribeComputeEnvironmentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeComputeEnvironmentsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    computeEnvironments: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeComputeEnvironmentsCommand");
+var de_DescribeComputeEnvironmentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeComputeEnvironmentsCommandError");
+var de_DescribeJobDefinitionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeJobDefinitionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeJobDefinitionsCommand");
+var de_DescribeJobDefinitionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeJobDefinitionsCommandError");
+var de_DescribeJobQueuesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeJobQueuesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobQueues: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeJobQueuesCommand");
+var de_DescribeJobQueuesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeJobQueuesCommandError");
+var de_DescribeJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeJobsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeJobsCommand");
+var de_DescribeJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeJobsCommandError");
+var de_DescribeSchedulingPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeSchedulingPoliciesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    schedulingPolicies: (_) => de_SchedulingPolicyDetailList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeSchedulingPoliciesCommand");
+var de_DescribeSchedulingPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSchedulingPoliciesCommandError");
+var de_ListJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListJobsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobSummaryList: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListJobsCommand");
+var de_ListJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListJobsCommandError");
+var de_ListSchedulingPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListSchedulingPoliciesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    nextToken: import_smithy_client.expectString,
+    schedulingPolicies: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSchedulingPoliciesCommand");
+var de_ListSchedulingPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSchedulingPoliciesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_RegisterJobDefinitionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RegisterJobDefinitionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobDefinitionArn: import_smithy_client.expectString,
+    jobDefinitionName: import_smithy_client.expectString,
+    revision: import_smithy_client.expectInt32
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RegisterJobDefinitionCommand");
+var de_RegisterJobDefinitionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterJobDefinitionCommandError");
+var de_SubmitJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SubmitJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobArn: import_smithy_client.expectString,
+    jobId: import_smithy_client.expectString,
+    jobName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SubmitJobCommand");
+var de_SubmitJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SubmitJobCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_TerminateJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TerminateJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TerminateJobCommand");
+var de_TerminateJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TerminateJobCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateComputeEnvironmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateComputeEnvironmentCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    computeEnvironmentArn: import_smithy_client.expectString,
+    computeEnvironmentName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateComputeEnvironmentCommand");
+var de_UpdateComputeEnvironmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateComputeEnvironmentCommandError");
+var de_UpdateJobQueueCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateJobQueueCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  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, {
+    jobQueueArn: import_smithy_client.expectString,
+    jobQueueName: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateJobQueueCommand");
+var de_UpdateJobQueueCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateJobQueueCommandError");
+var de_UpdateSchedulingPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateSchedulingPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateSchedulingPolicyCommand");
+var de_UpdateSchedulingPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClientException":
+    case "com.amazonaws.batch#ClientException":
+      throw await de_ClientExceptionRes(parsedOutput, context);
+    case "ServerException":
+    case "com.amazonaws.batch#ServerException":
+      throw await de_ServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSchedulingPolicyCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(BatchServiceException);
+var de_ClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ClientException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ClientExceptionRes");
+var de_ServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServerExceptionRes");
+var se_FairsharePolicy = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    computeReservation: [],
+    shareDecaySeconds: [],
+    shareDistribution: (_) => se_ShareAttributesList(_, context)
+  });
+}, "se_FairsharePolicy");
+var se_ShareAttributes = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    shareIdentifier: [],
+    weightFactor: import_smithy_client.serializeFloat
+  });
+}, "se_ShareAttributes");
+var se_ShareAttributesList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ShareAttributes(entry, context);
+  });
+}, "se_ShareAttributesList");
+var de_FairsharePolicy = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    computeReservation: import_smithy_client.expectInt32,
+    shareDecaySeconds: import_smithy_client.expectInt32,
+    shareDistribution: (_) => de_ShareAttributesList(_, context)
+  });
+}, "de_FairsharePolicy");
+var de_SchedulingPolicyDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    fairsharePolicy: (_) => de_FairsharePolicy(_, context),
+    name: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_SchedulingPolicyDetail");
+var de_SchedulingPolicyDetailList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SchedulingPolicyDetail(entry, context);
+  });
+  return retVal;
+}, "de_SchedulingPolicyDetailList");
+var de_ShareAttributes = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    shareIdentifier: import_smithy_client.expectString,
+    weightFactor: import_smithy_client.limitedParseFloat32
+  });
+}, "de_ShareAttributes");
+var de_ShareAttributesList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ShareAttributes(entry, context);
+  });
+  return retVal;
+}, "de_ShareAttributesList");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CancelJobCommand.ts
+var _CancelJobCommand = class _CancelJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "CancelJob", {}).n("BatchClient", "CancelJobCommand").f(void 0, void 0).ser(se_CancelJobCommand).de(de_CancelJobCommand).build() {
+};
+__name(_CancelJobCommand, "CancelJobCommand");
+var CancelJobCommand = _CancelJobCommand;
+
+// src/commands/CreateComputeEnvironmentCommand.ts
+
+
+
+
+var _CreateComputeEnvironmentCommand = class _CreateComputeEnvironmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "CreateComputeEnvironment", {}).n("BatchClient", "CreateComputeEnvironmentCommand").f(void 0, void 0).ser(se_CreateComputeEnvironmentCommand).de(de_CreateComputeEnvironmentCommand).build() {
+};
+__name(_CreateComputeEnvironmentCommand, "CreateComputeEnvironmentCommand");
+var CreateComputeEnvironmentCommand = _CreateComputeEnvironmentCommand;
+
+// src/commands/CreateJobQueueCommand.ts
+
+
+
+
+var _CreateJobQueueCommand = class _CreateJobQueueCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "CreateJobQueue", {}).n("BatchClient", "CreateJobQueueCommand").f(void 0, void 0).ser(se_CreateJobQueueCommand).de(de_CreateJobQueueCommand).build() {
+};
+__name(_CreateJobQueueCommand, "CreateJobQueueCommand");
+var CreateJobQueueCommand = _CreateJobQueueCommand;
+
+// src/commands/CreateSchedulingPolicyCommand.ts
+
+
+
+
+var _CreateSchedulingPolicyCommand = class _CreateSchedulingPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "CreateSchedulingPolicy", {}).n("BatchClient", "CreateSchedulingPolicyCommand").f(void 0, void 0).ser(se_CreateSchedulingPolicyCommand).de(de_CreateSchedulingPolicyCommand).build() {
+};
+__name(_CreateSchedulingPolicyCommand, "CreateSchedulingPolicyCommand");
+var CreateSchedulingPolicyCommand = _CreateSchedulingPolicyCommand;
+
+// src/commands/DeleteComputeEnvironmentCommand.ts
+
+
+
+
+var _DeleteComputeEnvironmentCommand = class _DeleteComputeEnvironmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DeleteComputeEnvironment", {}).n("BatchClient", "DeleteComputeEnvironmentCommand").f(void 0, void 0).ser(se_DeleteComputeEnvironmentCommand).de(de_DeleteComputeEnvironmentCommand).build() {
+};
+__name(_DeleteComputeEnvironmentCommand, "DeleteComputeEnvironmentCommand");
+var DeleteComputeEnvironmentCommand = _DeleteComputeEnvironmentCommand;
+
+// src/commands/DeleteJobQueueCommand.ts
+
+
+
+
+var _DeleteJobQueueCommand = class _DeleteJobQueueCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DeleteJobQueue", {}).n("BatchClient", "DeleteJobQueueCommand").f(void 0, void 0).ser(se_DeleteJobQueueCommand).de(de_DeleteJobQueueCommand).build() {
+};
+__name(_DeleteJobQueueCommand, "DeleteJobQueueCommand");
+var DeleteJobQueueCommand = _DeleteJobQueueCommand;
+
+// src/commands/DeleteSchedulingPolicyCommand.ts
+
+
+
+
+var _DeleteSchedulingPolicyCommand = class _DeleteSchedulingPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DeleteSchedulingPolicy", {}).n("BatchClient", "DeleteSchedulingPolicyCommand").f(void 0, void 0).ser(se_DeleteSchedulingPolicyCommand).de(de_DeleteSchedulingPolicyCommand).build() {
+};
+__name(_DeleteSchedulingPolicyCommand, "DeleteSchedulingPolicyCommand");
+var DeleteSchedulingPolicyCommand = _DeleteSchedulingPolicyCommand;
+
+// src/commands/DeregisterJobDefinitionCommand.ts
+
+
+
+
+var _DeregisterJobDefinitionCommand = class _DeregisterJobDefinitionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DeregisterJobDefinition", {}).n("BatchClient", "DeregisterJobDefinitionCommand").f(void 0, void 0).ser(se_DeregisterJobDefinitionCommand).de(de_DeregisterJobDefinitionCommand).build() {
+};
+__name(_DeregisterJobDefinitionCommand, "DeregisterJobDefinitionCommand");
+var DeregisterJobDefinitionCommand = _DeregisterJobDefinitionCommand;
+
+// src/commands/DescribeComputeEnvironmentsCommand.ts
+
+
+
+
+var _DescribeComputeEnvironmentsCommand = class _DescribeComputeEnvironmentsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DescribeComputeEnvironments", {}).n("BatchClient", "DescribeComputeEnvironmentsCommand").f(void 0, void 0).ser(se_DescribeComputeEnvironmentsCommand).de(de_DescribeComputeEnvironmentsCommand).build() {
+};
+__name(_DescribeComputeEnvironmentsCommand, "DescribeComputeEnvironmentsCommand");
+var DescribeComputeEnvironmentsCommand = _DescribeComputeEnvironmentsCommand;
+
+// src/commands/DescribeJobDefinitionsCommand.ts
+
+
+
+
+var _DescribeJobDefinitionsCommand = class _DescribeJobDefinitionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DescribeJobDefinitions", {}).n("BatchClient", "DescribeJobDefinitionsCommand").f(void 0, void 0).ser(se_DescribeJobDefinitionsCommand).de(de_DescribeJobDefinitionsCommand).build() {
+};
+__name(_DescribeJobDefinitionsCommand, "DescribeJobDefinitionsCommand");
+var DescribeJobDefinitionsCommand = _DescribeJobDefinitionsCommand;
+
+// src/commands/DescribeJobQueuesCommand.ts
+
+
+
+
+var _DescribeJobQueuesCommand = class _DescribeJobQueuesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DescribeJobQueues", {}).n("BatchClient", "DescribeJobQueuesCommand").f(void 0, void 0).ser(se_DescribeJobQueuesCommand).de(de_DescribeJobQueuesCommand).build() {
+};
+__name(_DescribeJobQueuesCommand, "DescribeJobQueuesCommand");
+var DescribeJobQueuesCommand = _DescribeJobQueuesCommand;
+
+// src/commands/DescribeJobsCommand.ts
+
+
+
+
+var _DescribeJobsCommand = class _DescribeJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DescribeJobs", {}).n("BatchClient", "DescribeJobsCommand").f(void 0, void 0).ser(se_DescribeJobsCommand).de(de_DescribeJobsCommand).build() {
+};
+__name(_DescribeJobsCommand, "DescribeJobsCommand");
+var DescribeJobsCommand = _DescribeJobsCommand;
+
+// src/commands/DescribeSchedulingPoliciesCommand.ts
+
+
+
+
+var _DescribeSchedulingPoliciesCommand = class _DescribeSchedulingPoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "DescribeSchedulingPolicies", {}).n("BatchClient", "DescribeSchedulingPoliciesCommand").f(void 0, void 0).ser(se_DescribeSchedulingPoliciesCommand).de(de_DescribeSchedulingPoliciesCommand).build() {
+};
+__name(_DescribeSchedulingPoliciesCommand, "DescribeSchedulingPoliciesCommand");
+var DescribeSchedulingPoliciesCommand = _DescribeSchedulingPoliciesCommand;
+
+// src/commands/ListJobsCommand.ts
+
+
+
+
+var _ListJobsCommand = class _ListJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "ListJobs", {}).n("BatchClient", "ListJobsCommand").f(void 0, void 0).ser(se_ListJobsCommand).de(de_ListJobsCommand).build() {
+};
+__name(_ListJobsCommand, "ListJobsCommand");
+var ListJobsCommand = _ListJobsCommand;
+
+// src/commands/ListSchedulingPoliciesCommand.ts
+
+
+
+
+var _ListSchedulingPoliciesCommand = class _ListSchedulingPoliciesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "ListSchedulingPolicies", {}).n("BatchClient", "ListSchedulingPoliciesCommand").f(void 0, void 0).ser(se_ListSchedulingPoliciesCommand).de(de_ListSchedulingPoliciesCommand).build() {
+};
+__name(_ListSchedulingPoliciesCommand, "ListSchedulingPoliciesCommand");
+var ListSchedulingPoliciesCommand = _ListSchedulingPoliciesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "ListTagsForResource", {}).n("BatchClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/RegisterJobDefinitionCommand.ts
+
+
+
+
+var _RegisterJobDefinitionCommand = class _RegisterJobDefinitionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "RegisterJobDefinition", {}).n("BatchClient", "RegisterJobDefinitionCommand").f(void 0, void 0).ser(se_RegisterJobDefinitionCommand).de(de_RegisterJobDefinitionCommand).build() {
+};
+__name(_RegisterJobDefinitionCommand, "RegisterJobDefinitionCommand");
+var RegisterJobDefinitionCommand = _RegisterJobDefinitionCommand;
+
+// src/commands/SubmitJobCommand.ts
+
+
+
+
+var _SubmitJobCommand = class _SubmitJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "SubmitJob", {}).n("BatchClient", "SubmitJobCommand").f(void 0, void 0).ser(se_SubmitJobCommand).de(de_SubmitJobCommand).build() {
+};
+__name(_SubmitJobCommand, "SubmitJobCommand");
+var SubmitJobCommand = _SubmitJobCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "TagResource", {}).n("BatchClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/TerminateJobCommand.ts
+
+
+
+
+var _TerminateJobCommand = class _TerminateJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "TerminateJob", {}).n("BatchClient", "TerminateJobCommand").f(void 0, void 0).ser(se_TerminateJobCommand).de(de_TerminateJobCommand).build() {
+};
+__name(_TerminateJobCommand, "TerminateJobCommand");
+var TerminateJobCommand = _TerminateJobCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "UntagResource", {}).n("BatchClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateComputeEnvironmentCommand.ts
+
+
+
+
+var _UpdateComputeEnvironmentCommand = class _UpdateComputeEnvironmentCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "UpdateComputeEnvironment", {}).n("BatchClient", "UpdateComputeEnvironmentCommand").f(void 0, void 0).ser(se_UpdateComputeEnvironmentCommand).de(de_UpdateComputeEnvironmentCommand).build() {
+};
+__name(_UpdateComputeEnvironmentCommand, "UpdateComputeEnvironmentCommand");
+var UpdateComputeEnvironmentCommand = _UpdateComputeEnvironmentCommand;
+
+// src/commands/UpdateJobQueueCommand.ts
+
+
+
+
+var _UpdateJobQueueCommand = class _UpdateJobQueueCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "UpdateJobQueue", {}).n("BatchClient", "UpdateJobQueueCommand").f(void 0, void 0).ser(se_UpdateJobQueueCommand).de(de_UpdateJobQueueCommand).build() {
+};
+__name(_UpdateJobQueueCommand, "UpdateJobQueueCommand");
+var UpdateJobQueueCommand = _UpdateJobQueueCommand;
+
+// src/commands/UpdateSchedulingPolicyCommand.ts
+
+
+
+
+var _UpdateSchedulingPolicyCommand = class _UpdateSchedulingPolicyCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSBatchV20160810", "UpdateSchedulingPolicy", {}).n("BatchClient", "UpdateSchedulingPolicyCommand").f(void 0, void 0).ser(se_UpdateSchedulingPolicyCommand).de(de_UpdateSchedulingPolicyCommand).build() {
+};
+__name(_UpdateSchedulingPolicyCommand, "UpdateSchedulingPolicyCommand");
+var UpdateSchedulingPolicyCommand = _UpdateSchedulingPolicyCommand;
+
+// src/Batch.ts
+var commands = {
+  CancelJobCommand,
+  CreateComputeEnvironmentCommand,
+  CreateJobQueueCommand,
+  CreateSchedulingPolicyCommand,
+  DeleteComputeEnvironmentCommand,
+  DeleteJobQueueCommand,
+  DeleteSchedulingPolicyCommand,
+  DeregisterJobDefinitionCommand,
+  DescribeComputeEnvironmentsCommand,
+  DescribeJobDefinitionsCommand,
+  DescribeJobQueuesCommand,
+  DescribeJobsCommand,
+  DescribeSchedulingPoliciesCommand,
+  ListJobsCommand,
+  ListSchedulingPoliciesCommand,
+  ListTagsForResourceCommand,
+  RegisterJobDefinitionCommand,
+  SubmitJobCommand,
+  TagResourceCommand,
+  TerminateJobCommand,
+  UntagResourceCommand,
+  UpdateComputeEnvironmentCommand,
+  UpdateJobQueueCommand,
+  UpdateSchedulingPolicyCommand
+};
+var _Batch = class _Batch extends BatchClient {
+};
+__name(_Batch, "Batch");
+var Batch = _Batch;
+(0, import_smithy_client.createAggregatedClient)(commands, Batch);
+
+// src/pagination/DescribeComputeEnvironmentsPaginator.ts
+
+var paginateDescribeComputeEnvironments = (0, import_core.createPaginator)(BatchClient, DescribeComputeEnvironmentsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeJobDefinitionsPaginator.ts
+
+var paginateDescribeJobDefinitions = (0, import_core.createPaginator)(BatchClient, DescribeJobDefinitionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeJobQueuesPaginator.ts
+
+var paginateDescribeJobQueues = (0, import_core.createPaginator)(BatchClient, DescribeJobQueuesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListJobsPaginator.ts
+
+var paginateListJobs = (0, import_core.createPaginator)(BatchClient, ListJobsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListSchedulingPoliciesPaginator.ts
+
+var paginateListSchedulingPolicies = (0, import_core.createPaginator)(BatchClient, ListSchedulingPoliciesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayJobDependency,
+  AssignPublicIp,
+  Batch,
+  BatchClient,
+  BatchServiceException,
+  CEState,
+  CEStatus,
+  CEType,
+  CRAllocationStrategy,
+  CRType,
+  CRUpdateAllocationStrategy,
+  CancelJobCommand,
+  ClientException,
+  CreateComputeEnvironmentCommand,
+  CreateJobQueueCommand,
+  CreateSchedulingPolicyCommand,
+  DeleteComputeEnvironmentCommand,
+  DeleteJobQueueCommand,
+  DeleteSchedulingPolicyCommand,
+  DeregisterJobDefinitionCommand,
+  DescribeComputeEnvironmentsCommand,
+  DescribeJobDefinitionsCommand,
+  DescribeJobQueuesCommand,
+  DescribeJobsCommand,
+  DescribeSchedulingPoliciesCommand,
+  DeviceCgroupPermission,
+  EFSAuthorizationConfigIAM,
+  EFSTransitEncryption,
+  JQState,
+  JQStatus,
+  JobDefinitionType,
+  JobStatus,
+  ListJobsCommand,
+  ListSchedulingPoliciesCommand,
+  ListTagsForResourceCommand,
+  LogDriver,
+  OrchestrationType,
+  PlatformCapability,
+  RegisterJobDefinitionCommand,
+  ResourceType,
+  RetryAction,
+  ServerException,
+  SubmitJobCommand,
+  TagResourceCommand,
+  TerminateJobCommand,
+  UntagResourceCommand,
+  UpdateComputeEnvironmentCommand,
+  UpdateJobQueueCommand,
+  UpdateSchedulingPolicyCommand,
+  __Client,
+  paginateDescribeComputeEnvironments,
+  paginateDescribeJobDefinitions,
+  paginateDescribeJobQueues,
+  paginateListJobs,
+  paginateListSchedulingPolicies
+});