import { HttpHandlerOptions as __HttpHandlerOptions } from "@aws-sdk/types" ; import { BatchClient } from "./BatchClient" ; import { CancelJobCommand , CancelJobCommandInput , CancelJobCommandOutput } from "./commands/CancelJobCommand" ; import { CreateComputeEnvironmentCommand , CreateComputeEnvironmentCommandInput , CreateComputeEnvironmentCommandOutput , } from "./commands/CreateComputeEnvironmentCommand" ; import { CreateJobQueueCommand , CreateJobQueueCommandInput , CreateJobQueueCommandOutput , } from "./commands/CreateJobQueueCommand" ; import { CreateSchedulingPolicyCommand , CreateSchedulingPolicyCommandInput , CreateSchedulingPolicyCommandOutput , } from "./commands/CreateSchedulingPolicyCommand" ; import { DeleteComputeEnvironmentCommand , DeleteComputeEnvironmentCommandInput , DeleteComputeEnvironmentCommandOutput , } from "./commands/DeleteComputeEnvironmentCommand" ; import { DeleteJobQueueCommand , DeleteJobQueueCommandInput , DeleteJobQueueCommandOutput , } from "./commands/DeleteJobQueueCommand" ; import { DeleteSchedulingPolicyCommand , DeleteSchedulingPolicyCommandInput , DeleteSchedulingPolicyCommandOutput , } from "./commands/DeleteSchedulingPolicyCommand" ; import { DeregisterJobDefinitionCommand , DeregisterJobDefinitionCommandInput , DeregisterJobDefinitionCommandOutput , } from "./commands/DeregisterJobDefinitionCommand" ; import { DescribeComputeEnvironmentsCommand , DescribeComputeEnvironmentsCommandInput , DescribeComputeEnvironmentsCommandOutput , } from "./commands/DescribeComputeEnvironmentsCommand" ; import { DescribeJobDefinitionsCommand , DescribeJobDefinitionsCommandInput , DescribeJobDefinitionsCommandOutput , } from "./commands/DescribeJobDefinitionsCommand" ; import { DescribeJobQueuesCommand , DescribeJobQueuesCommandInput , DescribeJobQueuesCommandOutput , } from "./commands/DescribeJobQueuesCommand" ; import { DescribeJobsCommand , DescribeJobsCommandInput , DescribeJobsCommandOutput , } from "./commands/DescribeJobsCommand" ; import { DescribeSchedulingPoliciesCommand , DescribeSchedulingPoliciesCommandInput , DescribeSchedulingPoliciesCommandOutput , } from "./commands/DescribeSchedulingPoliciesCommand" ; import { ListJobsCommand , ListJobsCommandInput , ListJobsCommandOutput } from "./commands/ListJobsCommand" ; import { ListSchedulingPoliciesCommand , ListSchedulingPoliciesCommandInput , ListSchedulingPoliciesCommandOutput , } from "./commands/ListSchedulingPoliciesCommand" ; import { ListTagsForResourceCommand , ListTagsForResourceCommandInput , ListTagsForResourceCommandOutput , } from "./commands/ListTagsForResourceCommand" ; import { RegisterJobDefinitionCommand , RegisterJobDefinitionCommandInput , RegisterJobDefinitionCommandOutput , } from "./commands/RegisterJobDefinitionCommand" ; import { SubmitJobCommand , SubmitJobCommandInput , SubmitJobCommandOutput } from "./commands/SubmitJobCommand" ; import { TagResourceCommand , TagResourceCommandInput , TagResourceCommandOutput } from "./commands/TagResourceCommand" ; import { TerminateJobCommand , TerminateJobCommandInput , TerminateJobCommandOutput , } from "./commands/TerminateJobCommand" ; import { UntagResourceCommand , UntagResourceCommandInput , UntagResourceCommandOutput , } from "./commands/UntagResourceCommand" ; import { UpdateComputeEnvironmentCommand , UpdateComputeEnvironmentCommandInput , UpdateComputeEnvironmentCommandOutput , } from "./commands/UpdateComputeEnvironmentCommand" ; import { UpdateJobQueueCommand , UpdateJobQueueCommandInput , UpdateJobQueueCommandOutput , } from "./commands/UpdateJobQueueCommand" ; import { UpdateSchedulingPolicyCommand , UpdateSchedulingPolicyCommandInput , UpdateSchedulingPolicyCommandOutput , } from "./commands/UpdateSchedulingPolicyCommand" ; /**
 * <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>
 *          <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>
 */ export 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>
     */ public cancelJob ( args , options ? ) ; public cancelJob ( args , cb ) ; public cancelJob ( args , options , cb ) ; public cancelJob ( args , optionsOrCb ? , cb ? ) { const command = new CancelJobCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Creates an Batch compute environment. You can create <code>MANAGED</code> or <code>UNMANAGED</code> compute
     *    environments. <code>MANAGED</code> compute environments can use Amazon EC2 or Fargate resources.
     *     <code>UNMANAGED</code> compute environments can only use EC2 resources.</p>
     *          <p>In a managed compute environment, Batch manages the capacity and instance types of the compute resources
     *    within the environment. This is based on the compute resource specification that you define or the <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html">launch template</a> that you
     *    specify when you create the compute environment. Either, you can choose to use EC2 On-Demand Instances and EC2 Spot
     *    Instances. Or, you can use Fargate and Fargate Spot capacity in your managed compute environment. You can
     *    optionally set a maximum price so that Spot Instances only launch when the Spot Instance price is less than a
     *    specified percentage of the On-Demand price.</p>
     *          <note>
     *             <p>Multi-node parallel jobs aren't supported on Spot Instances.</p>
     *          </note>
     *          <p>In an unmanaged compute environment, you can manage your own EC2 compute resources and have 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
     *    your container instances into that Amazon ECS cluster. For more information, see <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_container_instance.html">Launching an Amazon ECS container instance</a> in the
     *     <i>Amazon Elastic Container Service Developer Guide</i>.</p>
     *          <note>
     *             <p>Batch doesn't upgrade the AMIs in a compute environment after the environment is created. For example, it
     *     doesn't update the AMIs when a newer version of the Amazon ECS optimized AMI is available. Therefore, you're responsible
     *     for managing the guest operating system (including its updates and security patches) and any additional application
     *     software or utilities that you install on the compute resources. To use a new AMI for your Batch jobs, complete
     *     these steps:</p>
     *             <ol>
     *                <li>
     *                   <p>Create a new compute environment with the new AMI.</p>
     *                </li>
     *                <li>
     *                   <p>Add the compute environment to an existing job queue.</p>
     *                </li>
     *                <li>
     *                   <p>Remove the earlier compute environment from your job queue.</p>
     *                </li>
     *                <li>
     *                   <p>Delete the earlier compute environment.</p>
     *                </li>
     *             </ol>
     *          </note>
     */ public createComputeEnvironment ( args , options ? ) ; public createComputeEnvironment ( args , cb ) ; public createComputeEnvironment ( args , options , cb ) ; public createComputeEnvironment ( args , optionsOrCb ? , cb ? ) { const command = new CreateComputeEnvironmentCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Creates an Batch job queue. When you create a job queue, you associate one or more compute environments to the
     *    queue and assign an order of preference for the compute environments.</p>
     *          <p>You also set a priority to the job queue that determines the order that the Batch scheduler places jobs onto
     *    its associated compute environments. For example, if a compute environment is associated with more than one job
     *    queue, the job queue with a higher priority is given preference for scheduling jobs to that compute
     *    environment.</p>
     */ public createJobQueue ( args , options ? ) ; public createJobQueue ( args , cb ) ; public createJobQueue ( args , options , cb ) ; public createJobQueue ( args , optionsOrCb ? , cb ? ) { const command = new CreateJobQueueCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Creates an Batch scheduling policy.</p>
     */ public createSchedulingPolicy ( args , options ? ) ; public createSchedulingPolicy ( args , cb ) ; public createSchedulingPolicy ( args , options , cb ) ; public createSchedulingPolicy ( args , optionsOrCb ? , cb ? ) { const command = new CreateSchedulingPolicyCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Deletes an Batch compute environment.</p>
     *          <p>Before you can delete a compute environment, you must set its state to <code>DISABLED</code> with the <a>UpdateComputeEnvironment</a> API operation and disassociate it from any job queues with the <a>UpdateJobQueue</a> API operation. Compute environments that use Fargate resources must terminate all
     *    active jobs on that compute environment before deleting the compute environment. If this isn't done, the compute
     *    environment enters an invalid state.</p>
     */ public deleteComputeEnvironment ( args , options ? ) ; public deleteComputeEnvironment ( args , cb ) ; public deleteComputeEnvironment ( args , options , cb ) ; public deleteComputeEnvironment ( args , optionsOrCb ? , cb ? ) { const command = new DeleteComputeEnvironmentCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Deletes the specified job queue. You must first disable submissions for a queue with the <a>UpdateJobQueue</a> operation. All jobs in the queue are eventually terminated when you delete a job queue.
     *    The jobs are terminated at a rate of about 16 jobs each second.</p>
     *          <p>It's not necessary to disassociate compute environments from a queue before submitting a
     *     <code>DeleteJobQueue</code> request.</p>
     */ public deleteJobQueue ( args , options ? ) ; public deleteJobQueue ( args , cb ) ; public deleteJobQueue ( args , options , cb ) ; public deleteJobQueue ( args , optionsOrCb ? , cb ? ) { const command = new DeleteJobQueueCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Deletes the specified scheduling policy.</p>
     *          <p>You can't delete a scheduling policy that's used in any job queues.</p>
     */ public deleteSchedulingPolicy ( args , options ? ) ; public deleteSchedulingPolicy ( args , cb ) ; public deleteSchedulingPolicy ( args , options , cb ) ; public deleteSchedulingPolicy ( args , optionsOrCb ? , cb ? ) { const command = new DeleteSchedulingPolicyCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Deregisters an Batch job definition. Job definitions are permanently deleted after 180 days.</p>
     */ public deregisterJobDefinition ( args , options ? ) ; public deregisterJobDefinition ( args , cb ) ; public deregisterJobDefinition ( args , options , cb ) ; public deregisterJobDefinition ( args , optionsOrCb ? , cb ? ) { const command = new DeregisterJobDefinitionCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Describes one or more of your compute environments.</p>
     *          <p>If you're using an unmanaged compute environment, you can use the <code>DescribeComputeEnvironment</code>
     *    operation to determine the <code>ecsClusterArn</code> that you should launch your Amazon ECS container instances
     *    into.</p>
     */ public describeComputeEnvironments ( args , options ? ) ; public describeComputeEnvironments ( args , cb ) ; public describeComputeEnvironments ( args , options , cb ) ; public describeComputeEnvironments ( args , optionsOrCb ? , cb ? ) { const command = new DescribeComputeEnvironmentsCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Describes a list of job definitions. You can specify a <code>status</code> (such as <code>ACTIVE</code>) to only
     *    return job definitions that match that status.</p>
     */ public describeJobDefinitions ( args , options ? ) ; public describeJobDefinitions ( args , cb ) ; public describeJobDefinitions ( args , options , cb ) ; public describeJobDefinitions ( args , optionsOrCb ? , cb ? ) { const command = new DescribeJobDefinitionsCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Describes one or more of your job queues.</p>
     */ public describeJobQueues ( args , options ? ) ; public describeJobQueues ( args , cb ) ; public describeJobQueues ( args , options , cb ) ; public describeJobQueues ( args , optionsOrCb ? , cb ? ) { const command = new DescribeJobQueuesCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Describes a list of Batch jobs.</p>
     */ public describeJobs ( args , options ? ) ; public describeJobs ( args , cb ) ; public describeJobs ( args , options , cb ) ; public describeJobs ( args , optionsOrCb ? , cb ? ) { const command = new DescribeJobsCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Describes one or more of your scheduling policies.</p>
     */ public describeSchedulingPolicies ( args , options ? ) ; public describeSchedulingPolicies ( args , cb ) ; public describeSchedulingPolicies ( args , options , cb ) ; public describeSchedulingPolicies ( args , optionsOrCb ? , cb ? ) { const command = new DescribeSchedulingPoliciesCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Returns a list of Batch jobs.</p>
     *          <p>You must specify only one of the following items:</p>
     *          <ul>
     *             <li>
     *                <p>A job queue ID to return a list of jobs in that job queue</p>
     *             </li>
     *             <li>
     *                <p>A multi-node parallel job ID to return a list of nodes for that job</p>
     *             </li>
     *             <li>
     *                <p>An array job ID to return a list of the children for that job</p>
     *             </li>
     *          </ul>
     *          <p>You can filter the results by job status with the <code>jobStatus</code> parameter. If you don't specify a
     *    status, only <code>RUNNING</code> jobs are returned.</p>
     */ public listJobs ( args , options ? ) ; public listJobs ( args , cb ) ; public listJobs ( args , options , cb ) ; public listJobs ( args , optionsOrCb ? , cb ? ) { const command = new ListJobsCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Returns a list of Batch scheduling policies.</p>
     */ public listSchedulingPolicies ( args , options ? ) ; public listSchedulingPolicies ( args , cb ) ; public listSchedulingPolicies ( args , options , cb ) ; public listSchedulingPolicies ( args , optionsOrCb ? , cb ? ) { const command = new ListSchedulingPoliciesCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <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>
     */ public listTagsForResource ( args , options ? ) ; public listTagsForResource ( args , cb ) ; public listTagsForResource ( args , options , cb ) ; public listTagsForResource ( args , optionsOrCb ? , cb ? ) { const command = new ListTagsForResourceCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Registers an Batch job definition.</p>
     */ public registerJobDefinition ( args , options ? ) ; public registerJobDefinition ( args , cb ) ; public registerJobDefinition ( args , options , cb ) ; public registerJobDefinition ( args , optionsOrCb ? , cb ? ) { const command = new RegisterJobDefinitionCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Submits an Batch job from a job definition. Parameters that are specified during <a>SubmitJob</a>
     *    override parameters defined in the job definition. vCPU and memory requirements that are specified in the
     *     <code>resourceRequirements</code> objects in the job definition are the exception. They can't be overridden this way
     *    using the <code>memory</code> and <code>vcpus</code> parameters. Rather, you must specify updates to job definition
     *    parameters in a <code>ResourceRequirements</code> object that's included in the <code>containerOverrides</code>
     *    parameter.</p>
     *          <note>
     *             <p>Job queues with a scheduling policy are limited to 500 active fair share identifiers at a time. </p>
     *          </note>
     *          <important>
     *             <p>Jobs that run on Fargate resources can't be guaranteed to run for more than 14 days. This is because, after 14
     *     days, Fargate resources might become unavailable and job might be terminated.</p>
     *          </important>
     */ public submitJob ( args , options ? ) ; public submitJob ( args , cb ) ; public submitJob ( args , options , cb ) ; public submitJob ( args , optionsOrCb ? , cb ? ) { const command = new SubmitJobCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <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>
     */ public tagResource ( args , options ? ) ; public tagResource ( args , cb ) ; public tagResource ( args , options , cb ) ; public tagResource ( args , optionsOrCb ? , cb ? ) { const command = new TagResourceCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Terminates a job in a job queue. Jobs that are in the <code>STARTING</code> or <code>RUNNING</code> state are
     *    terminated, which causes them to transition to <code>FAILED</code>. Jobs that have not progressed to the
     *     <code>STARTING</code> state are cancelled.</p>
     */ public terminateJob ( args , options ? ) ; public terminateJob ( args , cb ) ; public terminateJob ( args , options , cb ) ; public terminateJob ( args , optionsOrCb ? , cb ? ) { const command = new TerminateJobCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Deletes specified tags from an Batch resource.</p>
     */ public untagResource ( args , options ? ) ; public untagResource ( args , cb ) ; public untagResource ( args , options , cb ) ; public untagResource ( args , optionsOrCb ? , cb ? ) { const command = new UntagResourceCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Updates an Batch compute environment.</p>
     */ public updateComputeEnvironment ( args , options ? ) ; public updateComputeEnvironment ( args , cb ) ; public updateComputeEnvironment ( args , options , cb ) ; public updateComputeEnvironment ( args , optionsOrCb ? , cb ? ) { const command = new UpdateComputeEnvironmentCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Updates a job queue.</p>
     */ public updateJobQueue ( args , options ? ) ; public updateJobQueue ( args , cb ) ; public updateJobQueue ( args , options , cb ) ; public updateJobQueue ( args , optionsOrCb ? , cb ? ) { const command = new UpdateJobQueueCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } /**
     * <p>Updates a scheduling policy.</p>
     */ public updateSchedulingPolicy ( args , options ? ) ; public updateSchedulingPolicy ( args , cb ) ; public updateSchedulingPolicy ( args , options , cb ) ; public updateSchedulingPolicy ( args , optionsOrCb ? , cb ? ) { const command = new UpdateSchedulingPolicyCommand ( args ) ; if ( typeof optionsOrCb === "function" ) { this . send ( command , optionsOrCb ) ; } else if ( typeof cb === "function" ) { if ( typeof optionsOrCb !== "object" ) throw new Error ( `Expect http options but get ${ typeof optionsOrCb }` ) ; this . send ( command , optionsOrCb || { } , cb ) ; } else { return this . send ( command , optionsOrCb ) ; } } }