AWS Batchv2016-08-10

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/canceljob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/canceljob" {:content-type :json
                                                         :form-params {:jobId ""
                                                                       :reason ""}})

require "http/client"

url = "{{baseUrl}}/v1/canceljob"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/canceljob"),
    Content = new StringContent("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/canceljob");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/canceljob"

	payload := strings.NewReader("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/canceljob HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "jobId": "",
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/canceljob")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/canceljob"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/canceljob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/canceljob")
  .header("content-type", "application/json")
  .body("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobId: '',
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/canceljob');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/canceljob',
  headers: {'content-type': 'application/json'},
  data: {jobId: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/canceljob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobId":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/canceljob',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobId": "",\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/canceljob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/canceljob',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobId: '', reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/canceljob',
  headers: {'content-type': 'application/json'},
  body: {jobId: '', reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/canceljob');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobId: '',
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/canceljob',
  headers: {'content-type': 'application/json'},
  data: {jobId: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/canceljob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobId":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobId": @"",
                              @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/canceljob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/canceljob" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/canceljob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobId' => '',
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/canceljob', [
  'body' => '{
  "jobId": "",
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/canceljob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobId' => '',
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobId' => '',
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/canceljob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/canceljob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobId": "",
  "reason": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/canceljob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobId": "",
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/canceljob", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/canceljob"

payload = {
    "jobId": "",
    "reason": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/canceljob"

payload <- "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/canceljob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/canceljob') do |req|
  req.body = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/canceljob";

    let payload = json!({
        "jobId": "",
        "reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobId": "",
  "reason": ""
}' |  \
  http POST {{baseUrl}}/v1/canceljob \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobId": "",\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/canceljob

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobId": "",
  "reason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/canceljob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/createcomputeenvironment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/createcomputeenvironment" {:content-type :json
                                                                        :form-params {:computeEnvironmentName ""
                                                                                      :type ""
                                                                                      :state ""
                                                                                      :unmanagedvCpus 0
                                                                                      :computeResources {:type ""
                                                                                                         :allocationStrategy ""
                                                                                                         :minvCpus ""
                                                                                                         :maxvCpus ""
                                                                                                         :desiredvCpus ""
                                                                                                         :instanceTypes ""
                                                                                                         :imageId ""
                                                                                                         :subnets ""
                                                                                                         :securityGroupIds ""
                                                                                                         :ec2KeyPair ""
                                                                                                         :instanceRole ""
                                                                                                         :tags ""
                                                                                                         :placementGroup ""
                                                                                                         :bidPercentage ""
                                                                                                         :spotIamFleetRole ""
                                                                                                         :launchTemplate ""
                                                                                                         :ec2Configuration ""}
                                                                                      :serviceRole ""
                                                                                      :tags {}
                                                                                      :eksConfiguration {:eksClusterArn ""
                                                                                                         :kubernetesNamespace ""}}})

require "http/client"

url = "{{baseUrl}}/v1/createcomputeenvironment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/createcomputeenvironment"),
    Content = new StringContent("{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/createcomputeenvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/createcomputeenvironment"

	payload := strings.NewReader("{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/createcomputeenvironment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 629

{
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  },
  "serviceRole": "",
  "tags": {},
  "eksConfiguration": {
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/createcomputeenvironment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/createcomputeenvironment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/createcomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/createcomputeenvironment")
  .header("content-type", "application/json")
  .body("{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  computeEnvironmentName: '',
  type: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    type: '',
    allocationStrategy: '',
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    instanceTypes: '',
    imageId: '',
    subnets: '',
    securityGroupIds: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    spotIamFleetRole: '',
    launchTemplate: '',
    ec2Configuration: ''
  },
  serviceRole: '',
  tags: {},
  eksConfiguration: {
    eksClusterArn: '',
    kubernetesNamespace: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/createcomputeenvironment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createcomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {
    computeEnvironmentName: '',
    type: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      type: '',
      allocationStrategy: '',
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      instanceTypes: '',
      imageId: '',
      subnets: '',
      securityGroupIds: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      spotIamFleetRole: '',
      launchTemplate: '',
      ec2Configuration: ''
    },
    serviceRole: '',
    tags: {},
    eksConfiguration: {eksClusterArn: '', kubernetesNamespace: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/createcomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironmentName":"","type":"","state":"","unmanagedvCpus":0,"computeResources":{"type":"","allocationStrategy":"","minvCpus":"","maxvCpus":"","desiredvCpus":"","instanceTypes":"","imageId":"","subnets":"","securityGroupIds":"","ec2KeyPair":"","instanceRole":"","tags":"","placementGroup":"","bidPercentage":"","spotIamFleetRole":"","launchTemplate":"","ec2Configuration":""},"serviceRole":"","tags":{},"eksConfiguration":{"eksClusterArn":"","kubernetesNamespace":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/createcomputeenvironment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "computeEnvironmentName": "",\n  "type": "",\n  "state": "",\n  "unmanagedvCpus": 0,\n  "computeResources": {\n    "type": "",\n    "allocationStrategy": "",\n    "minvCpus": "",\n    "maxvCpus": "",\n    "desiredvCpus": "",\n    "instanceTypes": "",\n    "imageId": "",\n    "subnets": "",\n    "securityGroupIds": "",\n    "ec2KeyPair": "",\n    "instanceRole": "",\n    "tags": "",\n    "placementGroup": "",\n    "bidPercentage": "",\n    "spotIamFleetRole": "",\n    "launchTemplate": "",\n    "ec2Configuration": ""\n  },\n  "serviceRole": "",\n  "tags": {},\n  "eksConfiguration": {\n    "eksClusterArn": "",\n    "kubernetesNamespace": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/createcomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/createcomputeenvironment',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  computeEnvironmentName: '',
  type: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    type: '',
    allocationStrategy: '',
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    instanceTypes: '',
    imageId: '',
    subnets: '',
    securityGroupIds: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    spotIamFleetRole: '',
    launchTemplate: '',
    ec2Configuration: ''
  },
  serviceRole: '',
  tags: {},
  eksConfiguration: {eksClusterArn: '', kubernetesNamespace: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createcomputeenvironment',
  headers: {'content-type': 'application/json'},
  body: {
    computeEnvironmentName: '',
    type: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      type: '',
      allocationStrategy: '',
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      instanceTypes: '',
      imageId: '',
      subnets: '',
      securityGroupIds: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      spotIamFleetRole: '',
      launchTemplate: '',
      ec2Configuration: ''
    },
    serviceRole: '',
    tags: {},
    eksConfiguration: {eksClusterArn: '', kubernetesNamespace: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/createcomputeenvironment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  computeEnvironmentName: '',
  type: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    type: '',
    allocationStrategy: '',
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    instanceTypes: '',
    imageId: '',
    subnets: '',
    securityGroupIds: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    spotIamFleetRole: '',
    launchTemplate: '',
    ec2Configuration: ''
  },
  serviceRole: '',
  tags: {},
  eksConfiguration: {
    eksClusterArn: '',
    kubernetesNamespace: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createcomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {
    computeEnvironmentName: '',
    type: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      type: '',
      allocationStrategy: '',
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      instanceTypes: '',
      imageId: '',
      subnets: '',
      securityGroupIds: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      spotIamFleetRole: '',
      launchTemplate: '',
      ec2Configuration: ''
    },
    serviceRole: '',
    tags: {},
    eksConfiguration: {eksClusterArn: '', kubernetesNamespace: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/createcomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironmentName":"","type":"","state":"","unmanagedvCpus":0,"computeResources":{"type":"","allocationStrategy":"","minvCpus":"","maxvCpus":"","desiredvCpus":"","instanceTypes":"","imageId":"","subnets":"","securityGroupIds":"","ec2KeyPair":"","instanceRole":"","tags":"","placementGroup":"","bidPercentage":"","spotIamFleetRole":"","launchTemplate":"","ec2Configuration":""},"serviceRole":"","tags":{},"eksConfiguration":{"eksClusterArn":"","kubernetesNamespace":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"computeEnvironmentName": @"",
                              @"type": @"",
                              @"state": @"",
                              @"unmanagedvCpus": @0,
                              @"computeResources": @{ @"type": @"", @"allocationStrategy": @"", @"minvCpus": @"", @"maxvCpus": @"", @"desiredvCpus": @"", @"instanceTypes": @"", @"imageId": @"", @"subnets": @"", @"securityGroupIds": @"", @"ec2KeyPair": @"", @"instanceRole": @"", @"tags": @"", @"placementGroup": @"", @"bidPercentage": @"", @"spotIamFleetRole": @"", @"launchTemplate": @"", @"ec2Configuration": @"" },
                              @"serviceRole": @"",
                              @"tags": @{  },
                              @"eksConfiguration": @{ @"eksClusterArn": @"", @"kubernetesNamespace": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/createcomputeenvironment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/createcomputeenvironment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/createcomputeenvironment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'computeEnvironmentName' => '',
    'type' => '',
    'state' => '',
    'unmanagedvCpus' => 0,
    'computeResources' => [
        'type' => '',
        'allocationStrategy' => '',
        'minvCpus' => '',
        'maxvCpus' => '',
        'desiredvCpus' => '',
        'instanceTypes' => '',
        'imageId' => '',
        'subnets' => '',
        'securityGroupIds' => '',
        'ec2KeyPair' => '',
        'instanceRole' => '',
        'tags' => '',
        'placementGroup' => '',
        'bidPercentage' => '',
        'spotIamFleetRole' => '',
        'launchTemplate' => '',
        'ec2Configuration' => ''
    ],
    'serviceRole' => '',
    'tags' => [
        
    ],
    'eksConfiguration' => [
        'eksClusterArn' => '',
        'kubernetesNamespace' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/createcomputeenvironment', [
  'body' => '{
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  },
  "serviceRole": "",
  "tags": {},
  "eksConfiguration": {
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/createcomputeenvironment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'computeEnvironmentName' => '',
  'type' => '',
  'state' => '',
  'unmanagedvCpus' => 0,
  'computeResources' => [
    'type' => '',
    'allocationStrategy' => '',
    'minvCpus' => '',
    'maxvCpus' => '',
    'desiredvCpus' => '',
    'instanceTypes' => '',
    'imageId' => '',
    'subnets' => '',
    'securityGroupIds' => '',
    'ec2KeyPair' => '',
    'instanceRole' => '',
    'tags' => '',
    'placementGroup' => '',
    'bidPercentage' => '',
    'spotIamFleetRole' => '',
    'launchTemplate' => '',
    'ec2Configuration' => ''
  ],
  'serviceRole' => '',
  'tags' => [
    
  ],
  'eksConfiguration' => [
    'eksClusterArn' => '',
    'kubernetesNamespace' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'computeEnvironmentName' => '',
  'type' => '',
  'state' => '',
  'unmanagedvCpus' => 0,
  'computeResources' => [
    'type' => '',
    'allocationStrategy' => '',
    'minvCpus' => '',
    'maxvCpus' => '',
    'desiredvCpus' => '',
    'instanceTypes' => '',
    'imageId' => '',
    'subnets' => '',
    'securityGroupIds' => '',
    'ec2KeyPair' => '',
    'instanceRole' => '',
    'tags' => '',
    'placementGroup' => '',
    'bidPercentage' => '',
    'spotIamFleetRole' => '',
    'launchTemplate' => '',
    'ec2Configuration' => ''
  ],
  'serviceRole' => '',
  'tags' => [
    
  ],
  'eksConfiguration' => [
    'eksClusterArn' => '',
    'kubernetesNamespace' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/createcomputeenvironment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/createcomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  },
  "serviceRole": "",
  "tags": {},
  "eksConfiguration": {
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/createcomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  },
  "serviceRole": "",
  "tags": {},
  "eksConfiguration": {
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/createcomputeenvironment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/createcomputeenvironment"

payload = {
    "computeEnvironmentName": "",
    "type": "",
    "state": "",
    "unmanagedvCpus": 0,
    "computeResources": {
        "type": "",
        "allocationStrategy": "",
        "minvCpus": "",
        "maxvCpus": "",
        "desiredvCpus": "",
        "instanceTypes": "",
        "imageId": "",
        "subnets": "",
        "securityGroupIds": "",
        "ec2KeyPair": "",
        "instanceRole": "",
        "tags": "",
        "placementGroup": "",
        "bidPercentage": "",
        "spotIamFleetRole": "",
        "launchTemplate": "",
        "ec2Configuration": ""
    },
    "serviceRole": "",
    "tags": {},
    "eksConfiguration": {
        "eksClusterArn": "",
        "kubernetesNamespace": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/createcomputeenvironment"

payload <- "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/createcomputeenvironment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/createcomputeenvironment') do |req|
  req.body = "{\n  \"computeEnvironmentName\": \"\",\n  \"type\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"type\": \"\",\n    \"allocationStrategy\": \"\",\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"instanceTypes\": \"\",\n    \"imageId\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"spotIamFleetRole\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"tags\": {},\n  \"eksConfiguration\": {\n    \"eksClusterArn\": \"\",\n    \"kubernetesNamespace\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/createcomputeenvironment";

    let payload = json!({
        "computeEnvironmentName": "",
        "type": "",
        "state": "",
        "unmanagedvCpus": 0,
        "computeResources": json!({
            "type": "",
            "allocationStrategy": "",
            "minvCpus": "",
            "maxvCpus": "",
            "desiredvCpus": "",
            "instanceTypes": "",
            "imageId": "",
            "subnets": "",
            "securityGroupIds": "",
            "ec2KeyPair": "",
            "instanceRole": "",
            "tags": "",
            "placementGroup": "",
            "bidPercentage": "",
            "spotIamFleetRole": "",
            "launchTemplate": "",
            "ec2Configuration": ""
        }),
        "serviceRole": "",
        "tags": json!({}),
        "eksConfiguration": json!({
            "eksClusterArn": "",
            "kubernetesNamespace": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  },
  "serviceRole": "",
  "tags": {},
  "eksConfiguration": {
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/createcomputeenvironment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "computeEnvironmentName": "",\n  "type": "",\n  "state": "",\n  "unmanagedvCpus": 0,\n  "computeResources": {\n    "type": "",\n    "allocationStrategy": "",\n    "minvCpus": "",\n    "maxvCpus": "",\n    "desiredvCpus": "",\n    "instanceTypes": "",\n    "imageId": "",\n    "subnets": "",\n    "securityGroupIds": "",\n    "ec2KeyPair": "",\n    "instanceRole": "",\n    "tags": "",\n    "placementGroup": "",\n    "bidPercentage": "",\n    "spotIamFleetRole": "",\n    "launchTemplate": "",\n    "ec2Configuration": ""\n  },\n  "serviceRole": "",\n  "tags": {},\n  "eksConfiguration": {\n    "eksClusterArn": "",\n    "kubernetesNamespace": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/createcomputeenvironment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "computeEnvironmentName": "",
  "type": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": [
    "type": "",
    "allocationStrategy": "",
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "instanceTypes": "",
    "imageId": "",
    "subnets": "",
    "securityGroupIds": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "spotIamFleetRole": "",
    "launchTemplate": "",
    "ec2Configuration": ""
  ],
  "serviceRole": "",
  "tags": [],
  "eksConfiguration": [
    "eksClusterArn": "",
    "kubernetesNamespace": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/createcomputeenvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/createjobqueue");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/createjobqueue" {:content-type :json
                                                              :form-params {:jobQueueName ""
                                                                            :state ""
                                                                            :schedulingPolicyArn ""
                                                                            :priority 0
                                                                            :computeEnvironmentOrder [{:order ""
                                                                                                       :computeEnvironment ""}]
                                                                            :tags {}}})

require "http/client"

url = "{{baseUrl}}/v1/createjobqueue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/createjobqueue"),
    Content = new StringContent("{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/createjobqueue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/createjobqueue"

	payload := strings.NewReader("{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/createjobqueue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 197

{
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ],
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/createjobqueue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/createjobqueue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/createjobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/createjobqueue")
  .header("content-type", "application/json")
  .body("{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  jobQueueName: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [
    {
      order: '',
      computeEnvironment: ''
    }
  ],
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/createjobqueue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createjobqueue',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueueName: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}],
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/createjobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueueName":"","state":"","schedulingPolicyArn":"","priority":0,"computeEnvironmentOrder":[{"order":"","computeEnvironment":""}],"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/createjobqueue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobQueueName": "",\n  "state": "",\n  "schedulingPolicyArn": "",\n  "priority": 0,\n  "computeEnvironmentOrder": [\n    {\n      "order": "",\n      "computeEnvironment": ""\n    }\n  ],\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/createjobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/createjobqueue',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobQueueName: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [{order: '', computeEnvironment: ''}],
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createjobqueue',
  headers: {'content-type': 'application/json'},
  body: {
    jobQueueName: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}],
    tags: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/createjobqueue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobQueueName: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [
    {
      order: '',
      computeEnvironment: ''
    }
  ],
  tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createjobqueue',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueueName: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}],
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/createjobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueueName":"","state":"","schedulingPolicyArn":"","priority":0,"computeEnvironmentOrder":[{"order":"","computeEnvironment":""}],"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobQueueName": @"",
                              @"state": @"",
                              @"schedulingPolicyArn": @"",
                              @"priority": @0,
                              @"computeEnvironmentOrder": @[ @{ @"order": @"", @"computeEnvironment": @"" } ],
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/createjobqueue"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/createjobqueue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/createjobqueue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobQueueName' => '',
    'state' => '',
    'schedulingPolicyArn' => '',
    'priority' => 0,
    'computeEnvironmentOrder' => [
        [
                'order' => '',
                'computeEnvironment' => ''
        ]
    ],
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/createjobqueue', [
  'body' => '{
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ],
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/createjobqueue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobQueueName' => '',
  'state' => '',
  'schedulingPolicyArn' => '',
  'priority' => 0,
  'computeEnvironmentOrder' => [
    [
        'order' => '',
        'computeEnvironment' => ''
    ]
  ],
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobQueueName' => '',
  'state' => '',
  'schedulingPolicyArn' => '',
  'priority' => 0,
  'computeEnvironmentOrder' => [
    [
        'order' => '',
        'computeEnvironment' => ''
    ]
  ],
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/createjobqueue');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/createjobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ],
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/createjobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ],
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/createjobqueue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/createjobqueue"

payload = {
    "jobQueueName": "",
    "state": "",
    "schedulingPolicyArn": "",
    "priority": 0,
    "computeEnvironmentOrder": [
        {
            "order": "",
            "computeEnvironment": ""
        }
    ],
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/createjobqueue"

payload <- "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/createjobqueue")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/createjobqueue') do |req|
  req.body = "{\n  \"jobQueueName\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ],\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/createjobqueue";

    let payload = json!({
        "jobQueueName": "",
        "state": "",
        "schedulingPolicyArn": "",
        "priority": 0,
        "computeEnvironmentOrder": (
            json!({
                "order": "",
                "computeEnvironment": ""
            })
        ),
        "tags": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ],
  "tags": {}
}' |  \
  http POST {{baseUrl}}/v1/createjobqueue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobQueueName": "",\n  "state": "",\n  "schedulingPolicyArn": "",\n  "priority": 0,\n  "computeEnvironmentOrder": [\n    {\n      "order": "",\n      "computeEnvironment": ""\n    }\n  ],\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/v1/createjobqueue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobQueueName": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    [
      "order": "",
      "computeEnvironment": ""
    ]
  ],
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/createjobqueue")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/createschedulingpolicy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/createschedulingpolicy" {:content-type :json
                                                                      :form-params {:name ""
                                                                                    :fairsharePolicy {:shareDecaySeconds ""
                                                                                                      :computeReservation ""
                                                                                                      :shareDistribution ""}
                                                                                    :tags {}}})

require "http/client"

url = "{{baseUrl}}/v1/createschedulingpolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/createschedulingpolicy"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/createschedulingpolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/createschedulingpolicy"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/createschedulingpolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "name": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  },
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/createschedulingpolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/createschedulingpolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/createschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/createschedulingpolicy")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  fairsharePolicy: {
    shareDecaySeconds: '',
    computeReservation: '',
    shareDistribution: ''
  },
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/createschedulingpolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''},
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/createschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","fairsharePolicy":{"shareDecaySeconds":"","computeReservation":"","shareDistribution":""},"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/createschedulingpolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "fairsharePolicy": {\n    "shareDecaySeconds": "",\n    "computeReservation": "",\n    "shareDistribution": ""\n  },\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/createschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/createschedulingpolicy',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  name: '',
  fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''},
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createschedulingpolicy',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''},
    tags: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/createschedulingpolicy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  fairsharePolicy: {
    shareDecaySeconds: '',
    computeReservation: '',
    shareDistribution: ''
  },
  tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/createschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''},
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/createschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","fairsharePolicy":{"shareDecaySeconds":"","computeReservation":"","shareDistribution":""},"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"fairsharePolicy": @{ @"shareDecaySeconds": @"", @"computeReservation": @"", @"shareDistribution": @"" },
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/createschedulingpolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/createschedulingpolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/createschedulingpolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'fairsharePolicy' => [
        'shareDecaySeconds' => '',
        'computeReservation' => '',
        'shareDistribution' => ''
    ],
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/createschedulingpolicy', [
  'body' => '{
  "name": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  },
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/createschedulingpolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'fairsharePolicy' => [
    'shareDecaySeconds' => '',
    'computeReservation' => '',
    'shareDistribution' => ''
  ],
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'fairsharePolicy' => [
    'shareDecaySeconds' => '',
    'computeReservation' => '',
    'shareDistribution' => ''
  ],
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/createschedulingpolicy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/createschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  },
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/createschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  },
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/createschedulingpolicy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/createschedulingpolicy"

payload = {
    "name": "",
    "fairsharePolicy": {
        "shareDecaySeconds": "",
        "computeReservation": "",
        "shareDistribution": ""
    },
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/createschedulingpolicy"

payload <- "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/createschedulingpolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/createschedulingpolicy') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  },\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/createschedulingpolicy";

    let payload = json!({
        "name": "",
        "fairsharePolicy": json!({
            "shareDecaySeconds": "",
            "computeReservation": "",
            "shareDistribution": ""
        }),
        "tags": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "name": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  },
  "tags": {}
}' |  \
  http POST {{baseUrl}}/v1/createschedulingpolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "fairsharePolicy": {\n    "shareDecaySeconds": "",\n    "computeReservation": "",\n    "shareDistribution": ""\n  },\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/v1/createschedulingpolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "fairsharePolicy": [
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  ],
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/createschedulingpolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deletecomputeenvironment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"computeEnvironment\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/deletecomputeenvironment" {:content-type :json
                                                                        :form-params {:computeEnvironment ""}})

require "http/client"

url = "{{baseUrl}}/v1/deletecomputeenvironment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"computeEnvironment\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/deletecomputeenvironment"),
    Content = new StringContent("{\n  \"computeEnvironment\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/deletecomputeenvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"computeEnvironment\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/deletecomputeenvironment"

	payload := strings.NewReader("{\n  \"computeEnvironment\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/deletecomputeenvironment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 30

{
  "computeEnvironment": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/deletecomputeenvironment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"computeEnvironment\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deletecomputeenvironment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"computeEnvironment\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"computeEnvironment\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deletecomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/deletecomputeenvironment")
  .header("content-type", "application/json")
  .body("{\n  \"computeEnvironment\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  computeEnvironment: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/deletecomputeenvironment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletecomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {computeEnvironment: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/deletecomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironment":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deletecomputeenvironment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "computeEnvironment": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"computeEnvironment\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/deletecomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deletecomputeenvironment',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({computeEnvironment: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletecomputeenvironment',
  headers: {'content-type': 'application/json'},
  body: {computeEnvironment: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/deletecomputeenvironment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  computeEnvironment: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletecomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {computeEnvironment: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deletecomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironment":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"computeEnvironment": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deletecomputeenvironment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deletecomputeenvironment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"computeEnvironment\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/deletecomputeenvironment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'computeEnvironment' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/deletecomputeenvironment', [
  'body' => '{
  "computeEnvironment": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/deletecomputeenvironment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'computeEnvironment' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'computeEnvironment' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/deletecomputeenvironment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deletecomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironment": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deletecomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironment": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"computeEnvironment\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/deletecomputeenvironment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/deletecomputeenvironment"

payload = { "computeEnvironment": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/deletecomputeenvironment"

payload <- "{\n  \"computeEnvironment\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deletecomputeenvironment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"computeEnvironment\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/deletecomputeenvironment') do |req|
  req.body = "{\n  \"computeEnvironment\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deletecomputeenvironment";

    let payload = json!({"computeEnvironment": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "computeEnvironment": ""
}' |  \
  http POST {{baseUrl}}/v1/deletecomputeenvironment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "computeEnvironment": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/deletecomputeenvironment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["computeEnvironment": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deletecomputeenvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deletejobqueue");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobQueue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/deletejobqueue" {:content-type :json
                                                              :form-params {:jobQueue ""}})

require "http/client"

url = "{{baseUrl}}/v1/deletejobqueue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobQueue\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/deletejobqueue"),
    Content = new StringContent("{\n  \"jobQueue\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/deletejobqueue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobQueue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/deletejobqueue"

	payload := strings.NewReader("{\n  \"jobQueue\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/deletejobqueue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "jobQueue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/deletejobqueue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobQueue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deletejobqueue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobQueue\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deletejobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/deletejobqueue")
  .header("content-type", "application/json")
  .body("{\n  \"jobQueue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobQueue: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/deletejobqueue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletejobqueue',
  headers: {'content-type': 'application/json'},
  data: {jobQueue: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/deletejobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deletejobqueue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobQueue": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/deletejobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deletejobqueue',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobQueue: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletejobqueue',
  headers: {'content-type': 'application/json'},
  body: {jobQueue: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/deletejobqueue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobQueue: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deletejobqueue',
  headers: {'content-type': 'application/json'},
  data: {jobQueue: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deletejobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobQueue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deletejobqueue"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deletejobqueue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobQueue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/deletejobqueue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobQueue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/deletejobqueue', [
  'body' => '{
  "jobQueue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/deletejobqueue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobQueue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobQueue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/deletejobqueue');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deletejobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deletejobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobQueue\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/deletejobqueue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/deletejobqueue"

payload = { "jobQueue": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/deletejobqueue"

payload <- "{\n  \"jobQueue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deletejobqueue")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobQueue\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/deletejobqueue') do |req|
  req.body = "{\n  \"jobQueue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deletejobqueue";

    let payload = json!({"jobQueue": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobQueue": ""
}' |  \
  http POST {{baseUrl}}/v1/deletejobqueue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobQueue": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/deletejobqueue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["jobQueue": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deletejobqueue")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deleteschedulingpolicy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"arn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/deleteschedulingpolicy" {:content-type :json
                                                                      :form-params {:arn ""}})

require "http/client"

url = "{{baseUrl}}/v1/deleteschedulingpolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"arn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/deleteschedulingpolicy"),
    Content = new StringContent("{\n  \"arn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/deleteschedulingpolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"arn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/deleteschedulingpolicy"

	payload := strings.NewReader("{\n  \"arn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/deleteschedulingpolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 15

{
  "arn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/deleteschedulingpolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"arn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deleteschedulingpolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"arn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"arn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deleteschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/deleteschedulingpolicy")
  .header("content-type", "application/json")
  .body("{\n  \"arn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  arn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/deleteschedulingpolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deleteschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {arn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/deleteschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deleteschedulingpolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "arn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"arn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/deleteschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deleteschedulingpolicy',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({arn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deleteschedulingpolicy',
  headers: {'content-type': 'application/json'},
  body: {arn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/deleteschedulingpolicy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  arn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deleteschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {arn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deleteschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"arn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deleteschedulingpolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deleteschedulingpolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"arn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/deleteschedulingpolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'arn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/deleteschedulingpolicy', [
  'body' => '{
  "arn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/deleteschedulingpolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'arn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'arn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/deleteschedulingpolicy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deleteschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deleteschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"arn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/deleteschedulingpolicy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/deleteschedulingpolicy"

payload = { "arn": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/deleteschedulingpolicy"

payload <- "{\n  \"arn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deleteschedulingpolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"arn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/deleteschedulingpolicy') do |req|
  req.body = "{\n  \"arn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deleteschedulingpolicy";

    let payload = json!({"arn": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "arn": ""
}' |  \
  http POST {{baseUrl}}/v1/deleteschedulingpolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "arn": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/deleteschedulingpolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["arn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deleteschedulingpolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/deregisterjobdefinition");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/deregisterjobdefinition" {:content-type :json
                                                                       :form-params {:jobDefinition ""}})

require "http/client"

url = "{{baseUrl}}/v1/deregisterjobdefinition"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobDefinition\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/deregisterjobdefinition"),
    Content = new StringContent("{\n  \"jobDefinition\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/deregisterjobdefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobDefinition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/deregisterjobdefinition"

	payload := strings.NewReader("{\n  \"jobDefinition\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/deregisterjobdefinition HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 25

{
  "jobDefinition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/deregisterjobdefinition")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobDefinition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/deregisterjobdefinition"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobDefinition\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobDefinition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/deregisterjobdefinition")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/deregisterjobdefinition")
  .header("content-type", "application/json")
  .body("{\n  \"jobDefinition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobDefinition: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/deregisterjobdefinition');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deregisterjobdefinition',
  headers: {'content-type': 'application/json'},
  data: {jobDefinition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/deregisterjobdefinition';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/deregisterjobdefinition',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobDefinition": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/deregisterjobdefinition")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/deregisterjobdefinition',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobDefinition: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deregisterjobdefinition',
  headers: {'content-type': 'application/json'},
  body: {jobDefinition: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/deregisterjobdefinition');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobDefinition: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/deregisterjobdefinition',
  headers: {'content-type': 'application/json'},
  data: {jobDefinition: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/deregisterjobdefinition';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinition":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobDefinition": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/deregisterjobdefinition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/deregisterjobdefinition" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobDefinition\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/deregisterjobdefinition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobDefinition' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/deregisterjobdefinition', [
  'body' => '{
  "jobDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/deregisterjobdefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobDefinition' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/deregisterjobdefinition');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/deregisterjobdefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinition": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/deregisterjobdefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinition": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobDefinition\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/deregisterjobdefinition", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/deregisterjobdefinition"

payload = { "jobDefinition": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/deregisterjobdefinition"

payload <- "{\n  \"jobDefinition\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/deregisterjobdefinition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobDefinition\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/deregisterjobdefinition') do |req|
  req.body = "{\n  \"jobDefinition\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/deregisterjobdefinition";

    let payload = json!({"jobDefinition": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobDefinition": ""
}' |  \
  http POST {{baseUrl}}/v1/deregisterjobdefinition \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobDefinition": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/deregisterjobdefinition

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["jobDefinition": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/deregisterjobdefinition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/describecomputeenvironments");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/describecomputeenvironments" {:content-type :json
                                                                           :form-params {:computeEnvironments []
                                                                                         :maxResults 0
                                                                                         :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/v1/describecomputeenvironments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/describecomputeenvironments"),
    Content = new StringContent("{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/describecomputeenvironments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/describecomputeenvironments"

	payload := strings.NewReader("{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/describecomputeenvironments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/describecomputeenvironments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/describecomputeenvironments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/describecomputeenvironments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/describecomputeenvironments")
  .header("content-type", "application/json")
  .body("{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  computeEnvironments: [],
  maxResults: 0,
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/describecomputeenvironments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describecomputeenvironments',
  headers: {'content-type': 'application/json'},
  data: {computeEnvironments: [], maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/describecomputeenvironments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironments":[],"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/describecomputeenvironments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "computeEnvironments": [],\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/describecomputeenvironments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/describecomputeenvironments',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({computeEnvironments: [], maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describecomputeenvironments',
  headers: {'content-type': 'application/json'},
  body: {computeEnvironments: [], maxResults: 0, nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/describecomputeenvironments');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  computeEnvironments: [],
  maxResults: 0,
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describecomputeenvironments',
  headers: {'content-type': 'application/json'},
  data: {computeEnvironments: [], maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/describecomputeenvironments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironments":[],"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"computeEnvironments": @[  ],
                              @"maxResults": @0,
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/describecomputeenvironments"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/describecomputeenvironments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/describecomputeenvironments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'computeEnvironments' => [
        
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/describecomputeenvironments', [
  'body' => '{
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/describecomputeenvironments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'computeEnvironments' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'computeEnvironments' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/describecomputeenvironments');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/describecomputeenvironments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/describecomputeenvironments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/describecomputeenvironments", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/describecomputeenvironments"

payload = {
    "computeEnvironments": [],
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/describecomputeenvironments"

payload <- "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/describecomputeenvironments")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/describecomputeenvironments') do |req|
  req.body = "{\n  \"computeEnvironments\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/describecomputeenvironments";

    let payload = json!({
        "computeEnvironments": (),
        "maxResults": 0,
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/v1/describecomputeenvironments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "computeEnvironments": [],\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/describecomputeenvironments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "computeEnvironments": [],
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/describecomputeenvironments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/describejobdefinitions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/describejobdefinitions" {:content-type :json
                                                                      :form-params {:jobDefinitions []
                                                                                    :maxResults 0
                                                                                    :jobDefinitionName ""
                                                                                    :status ""
                                                                                    :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/v1/describejobdefinitions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/describejobdefinitions"),
    Content = new StringContent("{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/describejobdefinitions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/describejobdefinitions"

	payload := strings.NewReader("{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/describejobdefinitions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/describejobdefinitions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/describejobdefinitions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/describejobdefinitions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/describejobdefinitions")
  .header("content-type", "application/json")
  .body("{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobDefinitions: [],
  maxResults: 0,
  jobDefinitionName: '',
  status: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/describejobdefinitions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobdefinitions',
  headers: {'content-type': 'application/json'},
  data: {
    jobDefinitions: [],
    maxResults: 0,
    jobDefinitionName: '',
    status: '',
    nextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/describejobdefinitions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinitions":[],"maxResults":0,"jobDefinitionName":"","status":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/describejobdefinitions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobDefinitions": [],\n  "maxResults": 0,\n  "jobDefinitionName": "",\n  "status": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/describejobdefinitions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/describejobdefinitions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobDefinitions: [],
  maxResults: 0,
  jobDefinitionName: '',
  status: '',
  nextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobdefinitions',
  headers: {'content-type': 'application/json'},
  body: {
    jobDefinitions: [],
    maxResults: 0,
    jobDefinitionName: '',
    status: '',
    nextToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/describejobdefinitions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobDefinitions: [],
  maxResults: 0,
  jobDefinitionName: '',
  status: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobdefinitions',
  headers: {'content-type': 'application/json'},
  data: {
    jobDefinitions: [],
    maxResults: 0,
    jobDefinitionName: '',
    status: '',
    nextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/describejobdefinitions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinitions":[],"maxResults":0,"jobDefinitionName":"","status":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobDefinitions": @[  ],
                              @"maxResults": @0,
                              @"jobDefinitionName": @"",
                              @"status": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/describejobdefinitions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/describejobdefinitions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/describejobdefinitions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobDefinitions' => [
        
    ],
    'maxResults' => 0,
    'jobDefinitionName' => '',
    'status' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/describejobdefinitions', [
  'body' => '{
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/describejobdefinitions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobDefinitions' => [
    
  ],
  'maxResults' => 0,
  'jobDefinitionName' => '',
  'status' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobDefinitions' => [
    
  ],
  'maxResults' => 0,
  'jobDefinitionName' => '',
  'status' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/describejobdefinitions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/describejobdefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/describejobdefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/describejobdefinitions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/describejobdefinitions"

payload = {
    "jobDefinitions": [],
    "maxResults": 0,
    "jobDefinitionName": "",
    "status": "",
    "nextToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/describejobdefinitions"

payload <- "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/describejobdefinitions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/describejobdefinitions') do |req|
  req.body = "{\n  \"jobDefinitions\": [],\n  \"maxResults\": 0,\n  \"jobDefinitionName\": \"\",\n  \"status\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/describejobdefinitions";

    let payload = json!({
        "jobDefinitions": (),
        "maxResults": 0,
        "jobDefinitionName": "",
        "status": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/v1/describejobdefinitions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobDefinitions": [],\n  "maxResults": 0,\n  "jobDefinitionName": "",\n  "status": "",\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/describejobdefinitions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobDefinitions": [],
  "maxResults": 0,
  "jobDefinitionName": "",
  "status": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/describejobdefinitions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/describejobqueues");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/describejobqueues" {:content-type :json
                                                                 :form-params {:jobQueues []
                                                                               :maxResults 0
                                                                               :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/v1/describejobqueues"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/describejobqueues"),
    Content = new StringContent("{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/describejobqueues");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/describejobqueues"

	payload := strings.NewReader("{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/describejobqueues HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/describejobqueues")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/describejobqueues"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/describejobqueues")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/describejobqueues")
  .header("content-type", "application/json")
  .body("{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobQueues: [],
  maxResults: 0,
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/describejobqueues');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobqueues',
  headers: {'content-type': 'application/json'},
  data: {jobQueues: [], maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/describejobqueues';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueues":[],"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/describejobqueues',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobQueues": [],\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/describejobqueues")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/describejobqueues',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobQueues: [], maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobqueues',
  headers: {'content-type': 'application/json'},
  body: {jobQueues: [], maxResults: 0, nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/describejobqueues');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobQueues: [],
  maxResults: 0,
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobqueues',
  headers: {'content-type': 'application/json'},
  data: {jobQueues: [], maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/describejobqueues';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueues":[],"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobQueues": @[  ],
                              @"maxResults": @0,
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/describejobqueues"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/describejobqueues" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/describejobqueues",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobQueues' => [
        
    ],
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/describejobqueues', [
  'body' => '{
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/describejobqueues');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobQueues' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobQueues' => [
    
  ],
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/describejobqueues');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/describejobqueues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/describejobqueues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/describejobqueues", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/describejobqueues"

payload = {
    "jobQueues": [],
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/describejobqueues"

payload <- "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/describejobqueues")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/describejobqueues') do |req|
  req.body = "{\n  \"jobQueues\": [],\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/describejobqueues";

    let payload = json!({
        "jobQueues": (),
        "maxResults": 0,
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/v1/describejobqueues \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobQueues": [],\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/describejobqueues

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobQueues": [],
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/describejobqueues")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/describejobs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobs\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/describejobs" {:content-type :json
                                                            :form-params {:jobs []}})

require "http/client"

url = "{{baseUrl}}/v1/describejobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobs\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/describejobs"),
    Content = new StringContent("{\n  \"jobs\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/describejobs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobs\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/describejobs"

	payload := strings.NewReader("{\n  \"jobs\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/describejobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "jobs": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/describejobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobs\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/describejobs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobs\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobs\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/describejobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/describejobs")
  .header("content-type", "application/json")
  .body("{\n  \"jobs\": []\n}")
  .asString();

const data = JSON.stringify({
  jobs: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/describejobs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobs',
  headers: {'content-type': 'application/json'},
  data: {jobs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/describejobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobs":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/describejobs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobs": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobs\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/describejobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/describejobs',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobs: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobs',
  headers: {'content-type': 'application/json'},
  body: {jobs: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/describejobs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobs: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describejobs',
  headers: {'content-type': 'application/json'},
  data: {jobs: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/describejobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobs":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobs": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/describejobs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/describejobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobs\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/describejobs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobs' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/describejobs', [
  'body' => '{
  "jobs": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/describejobs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobs' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobs' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/describejobs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/describejobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobs": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/describejobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobs": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobs\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/describejobs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/describejobs"

payload = { "jobs": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/describejobs"

payload <- "{\n  \"jobs\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/describejobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobs\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/describejobs') do |req|
  req.body = "{\n  \"jobs\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/describejobs";

    let payload = json!({"jobs": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobs": []
}' |  \
  http POST {{baseUrl}}/v1/describejobs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobs": []\n}' \
  --output-document \
  - {{baseUrl}}/v1/describejobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["jobs": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/describejobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/describeschedulingpolicies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"arns\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/describeschedulingpolicies" {:content-type :json
                                                                          :form-params {:arns []}})

require "http/client"

url = "{{baseUrl}}/v1/describeschedulingpolicies"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"arns\": []\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/describeschedulingpolicies"),
    Content = new StringContent("{\n  \"arns\": []\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/describeschedulingpolicies");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"arns\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/describeschedulingpolicies"

	payload := strings.NewReader("{\n  \"arns\": []\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/describeschedulingpolicies HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "arns": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/describeschedulingpolicies")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"arns\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/describeschedulingpolicies"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"arns\": []\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"arns\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/describeschedulingpolicies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/describeschedulingpolicies")
  .header("content-type", "application/json")
  .body("{\n  \"arns\": []\n}")
  .asString();

const data = JSON.stringify({
  arns: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/describeschedulingpolicies');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describeschedulingpolicies',
  headers: {'content-type': 'application/json'},
  data: {arns: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/describeschedulingpolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arns":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/describeschedulingpolicies',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "arns": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"arns\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/describeschedulingpolicies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/describeschedulingpolicies',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({arns: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describeschedulingpolicies',
  headers: {'content-type': 'application/json'},
  body: {arns: []},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/describeschedulingpolicies');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  arns: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/describeschedulingpolicies',
  headers: {'content-type': 'application/json'},
  data: {arns: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/describeschedulingpolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arns":[]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"arns": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/describeschedulingpolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/describeschedulingpolicies" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"arns\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/describeschedulingpolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'arns' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/describeschedulingpolicies', [
  'body' => '{
  "arns": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/describeschedulingpolicies');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'arns' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'arns' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/describeschedulingpolicies');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/describeschedulingpolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arns": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/describeschedulingpolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arns": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"arns\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/describeschedulingpolicies", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/describeschedulingpolicies"

payload = { "arns": [] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/describeschedulingpolicies"

payload <- "{\n  \"arns\": []\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/describeschedulingpolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"arns\": []\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/describeschedulingpolicies') do |req|
  req.body = "{\n  \"arns\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/describeschedulingpolicies";

    let payload = json!({"arns": ()});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "arns": []
}' |  \
  http POST {{baseUrl}}/v1/describeschedulingpolicies \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "arns": []\n}' \
  --output-document \
  - {{baseUrl}}/v1/describeschedulingpolicies

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["arns": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/describeschedulingpolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/listjobs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/listjobs" {:content-type :json
                                                        :form-params {:jobQueue ""
                                                                      :arrayJobId ""
                                                                      :multiNodeJobId ""
                                                                      :jobStatus ""
                                                                      :maxResults 0
                                                                      :nextToken ""
                                                                      :filters [{:name ""
                                                                                 :values ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/listjobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/listjobs"),
    Content = new StringContent("{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/listjobs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/listjobs"

	payload := strings.NewReader("{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/listjobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 190

{
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    {
      "name": "",
      "values": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/listjobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/listjobs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/listjobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/listjobs")
  .header("content-type", "application/json")
  .body("{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  jobQueue: '',
  arrayJobId: '',
  multiNodeJobId: '',
  jobStatus: '',
  maxResults: 0,
  nextToken: '',
  filters: [
    {
      name: '',
      values: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/listjobs');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listjobs',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueue: '',
    arrayJobId: '',
    multiNodeJobId: '',
    jobStatus: '',
    maxResults: 0,
    nextToken: '',
    filters: [{name: '', values: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/listjobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":"","arrayJobId":"","multiNodeJobId":"","jobStatus":"","maxResults":0,"nextToken":"","filters":[{"name":"","values":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/listjobs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobQueue": "",\n  "arrayJobId": "",\n  "multiNodeJobId": "",\n  "jobStatus": "",\n  "maxResults": 0,\n  "nextToken": "",\n  "filters": [\n    {\n      "name": "",\n      "values": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/listjobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/listjobs',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobQueue: '',
  arrayJobId: '',
  multiNodeJobId: '',
  jobStatus: '',
  maxResults: 0,
  nextToken: '',
  filters: [{name: '', values: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listjobs',
  headers: {'content-type': 'application/json'},
  body: {
    jobQueue: '',
    arrayJobId: '',
    multiNodeJobId: '',
    jobStatus: '',
    maxResults: 0,
    nextToken: '',
    filters: [{name: '', values: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/listjobs');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobQueue: '',
  arrayJobId: '',
  multiNodeJobId: '',
  jobStatus: '',
  maxResults: 0,
  nextToken: '',
  filters: [
    {
      name: '',
      values: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listjobs',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueue: '',
    arrayJobId: '',
    multiNodeJobId: '',
    jobStatus: '',
    maxResults: 0,
    nextToken: '',
    filters: [{name: '', values: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/listjobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":"","arrayJobId":"","multiNodeJobId":"","jobStatus":"","maxResults":0,"nextToken":"","filters":[{"name":"","values":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobQueue": @"",
                              @"arrayJobId": @"",
                              @"multiNodeJobId": @"",
                              @"jobStatus": @"",
                              @"maxResults": @0,
                              @"nextToken": @"",
                              @"filters": @[ @{ @"name": @"", @"values": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/listjobs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/listjobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/listjobs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobQueue' => '',
    'arrayJobId' => '',
    'multiNodeJobId' => '',
    'jobStatus' => '',
    'maxResults' => 0,
    'nextToken' => '',
    'filters' => [
        [
                'name' => '',
                'values' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/listjobs', [
  'body' => '{
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    {
      "name": "",
      "values": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/listjobs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobQueue' => '',
  'arrayJobId' => '',
  'multiNodeJobId' => '',
  'jobStatus' => '',
  'maxResults' => 0,
  'nextToken' => '',
  'filters' => [
    [
        'name' => '',
        'values' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobQueue' => '',
  'arrayJobId' => '',
  'multiNodeJobId' => '',
  'jobStatus' => '',
  'maxResults' => 0,
  'nextToken' => '',
  'filters' => [
    [
        'name' => '',
        'values' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/listjobs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/listjobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    {
      "name": "",
      "values": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/listjobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    {
      "name": "",
      "values": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/listjobs", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/listjobs"

payload = {
    "jobQueue": "",
    "arrayJobId": "",
    "multiNodeJobId": "",
    "jobStatus": "",
    "maxResults": 0,
    "nextToken": "",
    "filters": [
        {
            "name": "",
            "values": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/listjobs"

payload <- "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/listjobs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/listjobs') do |req|
  req.body = "{\n  \"jobQueue\": \"\",\n  \"arrayJobId\": \"\",\n  \"multiNodeJobId\": \"\",\n  \"jobStatus\": \"\",\n  \"maxResults\": 0,\n  \"nextToken\": \"\",\n  \"filters\": [\n    {\n      \"name\": \"\",\n      \"values\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/listjobs";

    let payload = json!({
        "jobQueue": "",
        "arrayJobId": "",
        "multiNodeJobId": "",
        "jobStatus": "",
        "maxResults": 0,
        "nextToken": "",
        "filters": (
            json!({
                "name": "",
                "values": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    {
      "name": "",
      "values": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/listjobs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobQueue": "",\n  "arrayJobId": "",\n  "multiNodeJobId": "",\n  "jobStatus": "",\n  "maxResults": 0,\n  "nextToken": "",\n  "filters": [\n    {\n      "name": "",\n      "values": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/listjobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobQueue": "",
  "arrayJobId": "",
  "multiNodeJobId": "",
  "jobStatus": "",
  "maxResults": 0,
  "nextToken": "",
  "filters": [
    [
      "name": "",
      "values": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/listjobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/listschedulingpolicies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/listschedulingpolicies" {:content-type :json
                                                                      :form-params {:maxResults 0
                                                                                    :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/v1/listschedulingpolicies"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/listschedulingpolicies"),
    Content = new StringContent("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/listschedulingpolicies");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/listschedulingpolicies"

	payload := strings.NewReader("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/listschedulingpolicies HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "maxResults": 0,
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/listschedulingpolicies")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/listschedulingpolicies"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/listschedulingpolicies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/listschedulingpolicies")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: 0,
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/listschedulingpolicies');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listschedulingpolicies',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/listschedulingpolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/listschedulingpolicies',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": 0,\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/listschedulingpolicies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/listschedulingpolicies',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: 0, nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listschedulingpolicies',
  headers: {'content-type': 'application/json'},
  body: {maxResults: 0, nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/listschedulingpolicies');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: 0,
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/listschedulingpolicies',
  headers: {'content-type': 'application/json'},
  data: {maxResults: 0, nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/listschedulingpolicies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"maxResults":0,"nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @0,
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/listschedulingpolicies"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/listschedulingpolicies" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/listschedulingpolicies",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => 0,
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/listschedulingpolicies', [
  'body' => '{
  "maxResults": 0,
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/listschedulingpolicies');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => 0,
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => 0,
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/listschedulingpolicies');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/listschedulingpolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": 0,
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/listschedulingpolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": 0,
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/listschedulingpolicies", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/listschedulingpolicies"

payload = {
    "maxResults": 0,
    "nextToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/listschedulingpolicies"

payload <- "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/listschedulingpolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/listschedulingpolicies') do |req|
  req.body = "{\n  \"maxResults\": 0,\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/listschedulingpolicies";

    let payload = json!({
        "maxResults": 0,
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "maxResults": 0,
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/v1/listschedulingpolicies \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": 0,\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/listschedulingpolicies

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "maxResults": 0,
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/listschedulingpolicies")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/v1/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/v1/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/v1/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/tags/:resourceArn"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/v1/tags/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/v1/tags/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/v1/tags/:resourceArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/v1/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/v1/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/tags/:resourceArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/v1/tags/:resourceArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/v1/tags/:resourceArn');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/v1/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/tags/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/v1/tags/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/tags/:resourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/tags/:resourceArn' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/v1/tags/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/tags/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/v1/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/tags/:resourceArn";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/v1/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/v1/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/registerjobdefinition");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/registerjobdefinition" {:content-type :json
                                                                     :form-params {:jobDefinitionName ""
                                                                                   :type ""
                                                                                   :parameters {}
                                                                                   :schedulingPriority 0
                                                                                   :containerProperties {:image ""
                                                                                                         :vcpus ""
                                                                                                         :memory ""
                                                                                                         :command ""
                                                                                                         :jobRoleArn ""
                                                                                                         :executionRoleArn ""
                                                                                                         :volumes ""
                                                                                                         :environment ""
                                                                                                         :mountPoints ""
                                                                                                         :readonlyRootFilesystem ""
                                                                                                         :privileged ""
                                                                                                         :ulimits ""
                                                                                                         :user ""
                                                                                                         :instanceType ""
                                                                                                         :resourceRequirements ""
                                                                                                         :linuxParameters ""
                                                                                                         :logConfiguration ""
                                                                                                         :secrets ""
                                                                                                         :networkConfiguration ""
                                                                                                         :fargatePlatformConfiguration ""
                                                                                                         :ephemeralStorage ""}
                                                                                   :nodeProperties {:numNodes ""
                                                                                                    :mainNode ""
                                                                                                    :nodeRangeProperties ""}
                                                                                   :retryStrategy {:attempts ""
                                                                                                   :evaluateOnExit ""}
                                                                                   :propagateTags false
                                                                                   :timeout {:attemptDurationSeconds ""}
                                                                                   :tags {}
                                                                                   :platformCapabilities []
                                                                                   :eksProperties {:podProperties ""}}})

require "http/client"

url = "{{baseUrl}}/v1/registerjobdefinition"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/registerjobdefinition"),
    Content = new StringContent("{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/registerjobdefinition");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/registerjobdefinition"

	payload := strings.NewReader("{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/registerjobdefinition HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 969

{
  "jobDefinitionName": "",
  "type": "",
  "parameters": {},
  "schedulingPriority": 0,
  "containerProperties": {
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  },
  "nodeProperties": {
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "platformCapabilities": [],
  "eksProperties": {
    "podProperties": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/registerjobdefinition")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/registerjobdefinition"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/registerjobdefinition")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/registerjobdefinition")
  .header("content-type", "application/json")
  .body("{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  jobDefinitionName: '',
  type: '',
  parameters: {},
  schedulingPriority: 0,
  containerProperties: {
    image: '',
    vcpus: '',
    memory: '',
    command: '',
    jobRoleArn: '',
    executionRoleArn: '',
    volumes: '',
    environment: '',
    mountPoints: '',
    readonlyRootFilesystem: '',
    privileged: '',
    ulimits: '',
    user: '',
    instanceType: '',
    resourceRequirements: '',
    linuxParameters: '',
    logConfiguration: '',
    secrets: '',
    networkConfiguration: '',
    fargatePlatformConfiguration: '',
    ephemeralStorage: ''
  },
  nodeProperties: {
    numNodes: '',
    mainNode: '',
    nodeRangeProperties: ''
  },
  retryStrategy: {
    attempts: '',
    evaluateOnExit: ''
  },
  propagateTags: false,
  timeout: {
    attemptDurationSeconds: ''
  },
  tags: {},
  platformCapabilities: [],
  eksProperties: {
    podProperties: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/registerjobdefinition');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/registerjobdefinition',
  headers: {'content-type': 'application/json'},
  data: {
    jobDefinitionName: '',
    type: '',
    parameters: {},
    schedulingPriority: 0,
    containerProperties: {
      image: '',
      vcpus: '',
      memory: '',
      command: '',
      jobRoleArn: '',
      executionRoleArn: '',
      volumes: '',
      environment: '',
      mountPoints: '',
      readonlyRootFilesystem: '',
      privileged: '',
      ulimits: '',
      user: '',
      instanceType: '',
      resourceRequirements: '',
      linuxParameters: '',
      logConfiguration: '',
      secrets: '',
      networkConfiguration: '',
      fargatePlatformConfiguration: '',
      ephemeralStorage: ''
    },
    nodeProperties: {numNodes: '', mainNode: '', nodeRangeProperties: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    platformCapabilities: [],
    eksProperties: {podProperties: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/registerjobdefinition';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinitionName":"","type":"","parameters":{},"schedulingPriority":0,"containerProperties":{"image":"","vcpus":"","memory":"","command":"","jobRoleArn":"","executionRoleArn":"","volumes":"","environment":"","mountPoints":"","readonlyRootFilesystem":"","privileged":"","ulimits":"","user":"","instanceType":"","resourceRequirements":"","linuxParameters":"","logConfiguration":"","secrets":"","networkConfiguration":"","fargatePlatformConfiguration":"","ephemeralStorage":""},"nodeProperties":{"numNodes":"","mainNode":"","nodeRangeProperties":""},"retryStrategy":{"attempts":"","evaluateOnExit":""},"propagateTags":false,"timeout":{"attemptDurationSeconds":""},"tags":{},"platformCapabilities":[],"eksProperties":{"podProperties":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/registerjobdefinition',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobDefinitionName": "",\n  "type": "",\n  "parameters": {},\n  "schedulingPriority": 0,\n  "containerProperties": {\n    "image": "",\n    "vcpus": "",\n    "memory": "",\n    "command": "",\n    "jobRoleArn": "",\n    "executionRoleArn": "",\n    "volumes": "",\n    "environment": "",\n    "mountPoints": "",\n    "readonlyRootFilesystem": "",\n    "privileged": "",\n    "ulimits": "",\n    "user": "",\n    "instanceType": "",\n    "resourceRequirements": "",\n    "linuxParameters": "",\n    "logConfiguration": "",\n    "secrets": "",\n    "networkConfiguration": "",\n    "fargatePlatformConfiguration": "",\n    "ephemeralStorage": ""\n  },\n  "nodeProperties": {\n    "numNodes": "",\n    "mainNode": "",\n    "nodeRangeProperties": ""\n  },\n  "retryStrategy": {\n    "attempts": "",\n    "evaluateOnExit": ""\n  },\n  "propagateTags": false,\n  "timeout": {\n    "attemptDurationSeconds": ""\n  },\n  "tags": {},\n  "platformCapabilities": [],\n  "eksProperties": {\n    "podProperties": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/registerjobdefinition")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/registerjobdefinition',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobDefinitionName: '',
  type: '',
  parameters: {},
  schedulingPriority: 0,
  containerProperties: {
    image: '',
    vcpus: '',
    memory: '',
    command: '',
    jobRoleArn: '',
    executionRoleArn: '',
    volumes: '',
    environment: '',
    mountPoints: '',
    readonlyRootFilesystem: '',
    privileged: '',
    ulimits: '',
    user: '',
    instanceType: '',
    resourceRequirements: '',
    linuxParameters: '',
    logConfiguration: '',
    secrets: '',
    networkConfiguration: '',
    fargatePlatformConfiguration: '',
    ephemeralStorage: ''
  },
  nodeProperties: {numNodes: '', mainNode: '', nodeRangeProperties: ''},
  retryStrategy: {attempts: '', evaluateOnExit: ''},
  propagateTags: false,
  timeout: {attemptDurationSeconds: ''},
  tags: {},
  platformCapabilities: [],
  eksProperties: {podProperties: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/registerjobdefinition',
  headers: {'content-type': 'application/json'},
  body: {
    jobDefinitionName: '',
    type: '',
    parameters: {},
    schedulingPriority: 0,
    containerProperties: {
      image: '',
      vcpus: '',
      memory: '',
      command: '',
      jobRoleArn: '',
      executionRoleArn: '',
      volumes: '',
      environment: '',
      mountPoints: '',
      readonlyRootFilesystem: '',
      privileged: '',
      ulimits: '',
      user: '',
      instanceType: '',
      resourceRequirements: '',
      linuxParameters: '',
      logConfiguration: '',
      secrets: '',
      networkConfiguration: '',
      fargatePlatformConfiguration: '',
      ephemeralStorage: ''
    },
    nodeProperties: {numNodes: '', mainNode: '', nodeRangeProperties: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    platformCapabilities: [],
    eksProperties: {podProperties: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/registerjobdefinition');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobDefinitionName: '',
  type: '',
  parameters: {},
  schedulingPriority: 0,
  containerProperties: {
    image: '',
    vcpus: '',
    memory: '',
    command: '',
    jobRoleArn: '',
    executionRoleArn: '',
    volumes: '',
    environment: '',
    mountPoints: '',
    readonlyRootFilesystem: '',
    privileged: '',
    ulimits: '',
    user: '',
    instanceType: '',
    resourceRequirements: '',
    linuxParameters: '',
    logConfiguration: '',
    secrets: '',
    networkConfiguration: '',
    fargatePlatformConfiguration: '',
    ephemeralStorage: ''
  },
  nodeProperties: {
    numNodes: '',
    mainNode: '',
    nodeRangeProperties: ''
  },
  retryStrategy: {
    attempts: '',
    evaluateOnExit: ''
  },
  propagateTags: false,
  timeout: {
    attemptDurationSeconds: ''
  },
  tags: {},
  platformCapabilities: [],
  eksProperties: {
    podProperties: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/registerjobdefinition',
  headers: {'content-type': 'application/json'},
  data: {
    jobDefinitionName: '',
    type: '',
    parameters: {},
    schedulingPriority: 0,
    containerProperties: {
      image: '',
      vcpus: '',
      memory: '',
      command: '',
      jobRoleArn: '',
      executionRoleArn: '',
      volumes: '',
      environment: '',
      mountPoints: '',
      readonlyRootFilesystem: '',
      privileged: '',
      ulimits: '',
      user: '',
      instanceType: '',
      resourceRequirements: '',
      linuxParameters: '',
      logConfiguration: '',
      secrets: '',
      networkConfiguration: '',
      fargatePlatformConfiguration: '',
      ephemeralStorage: ''
    },
    nodeProperties: {numNodes: '', mainNode: '', nodeRangeProperties: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    platformCapabilities: [],
    eksProperties: {podProperties: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/registerjobdefinition';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobDefinitionName":"","type":"","parameters":{},"schedulingPriority":0,"containerProperties":{"image":"","vcpus":"","memory":"","command":"","jobRoleArn":"","executionRoleArn":"","volumes":"","environment":"","mountPoints":"","readonlyRootFilesystem":"","privileged":"","ulimits":"","user":"","instanceType":"","resourceRequirements":"","linuxParameters":"","logConfiguration":"","secrets":"","networkConfiguration":"","fargatePlatformConfiguration":"","ephemeralStorage":""},"nodeProperties":{"numNodes":"","mainNode":"","nodeRangeProperties":""},"retryStrategy":{"attempts":"","evaluateOnExit":""},"propagateTags":false,"timeout":{"attemptDurationSeconds":""},"tags":{},"platformCapabilities":[],"eksProperties":{"podProperties":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobDefinitionName": @"",
                              @"type": @"",
                              @"parameters": @{  },
                              @"schedulingPriority": @0,
                              @"containerProperties": @{ @"image": @"", @"vcpus": @"", @"memory": @"", @"command": @"", @"jobRoleArn": @"", @"executionRoleArn": @"", @"volumes": @"", @"environment": @"", @"mountPoints": @"", @"readonlyRootFilesystem": @"", @"privileged": @"", @"ulimits": @"", @"user": @"", @"instanceType": @"", @"resourceRequirements": @"", @"linuxParameters": @"", @"logConfiguration": @"", @"secrets": @"", @"networkConfiguration": @"", @"fargatePlatformConfiguration": @"", @"ephemeralStorage": @"" },
                              @"nodeProperties": @{ @"numNodes": @"", @"mainNode": @"", @"nodeRangeProperties": @"" },
                              @"retryStrategy": @{ @"attempts": @"", @"evaluateOnExit": @"" },
                              @"propagateTags": @NO,
                              @"timeout": @{ @"attemptDurationSeconds": @"" },
                              @"tags": @{  },
                              @"platformCapabilities": @[  ],
                              @"eksProperties": @{ @"podProperties": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/registerjobdefinition"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/registerjobdefinition" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/registerjobdefinition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobDefinitionName' => '',
    'type' => '',
    'parameters' => [
        
    ],
    'schedulingPriority' => 0,
    'containerProperties' => [
        'image' => '',
        'vcpus' => '',
        'memory' => '',
        'command' => '',
        'jobRoleArn' => '',
        'executionRoleArn' => '',
        'volumes' => '',
        'environment' => '',
        'mountPoints' => '',
        'readonlyRootFilesystem' => '',
        'privileged' => '',
        'ulimits' => '',
        'user' => '',
        'instanceType' => '',
        'resourceRequirements' => '',
        'linuxParameters' => '',
        'logConfiguration' => '',
        'secrets' => '',
        'networkConfiguration' => '',
        'fargatePlatformConfiguration' => '',
        'ephemeralStorage' => ''
    ],
    'nodeProperties' => [
        'numNodes' => '',
        'mainNode' => '',
        'nodeRangeProperties' => ''
    ],
    'retryStrategy' => [
        'attempts' => '',
        'evaluateOnExit' => ''
    ],
    'propagateTags' => null,
    'timeout' => [
        'attemptDurationSeconds' => ''
    ],
    'tags' => [
        
    ],
    'platformCapabilities' => [
        
    ],
    'eksProperties' => [
        'podProperties' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/registerjobdefinition', [
  'body' => '{
  "jobDefinitionName": "",
  "type": "",
  "parameters": {},
  "schedulingPriority": 0,
  "containerProperties": {
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  },
  "nodeProperties": {
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "platformCapabilities": [],
  "eksProperties": {
    "podProperties": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/registerjobdefinition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobDefinitionName' => '',
  'type' => '',
  'parameters' => [
    
  ],
  'schedulingPriority' => 0,
  'containerProperties' => [
    'image' => '',
    'vcpus' => '',
    'memory' => '',
    'command' => '',
    'jobRoleArn' => '',
    'executionRoleArn' => '',
    'volumes' => '',
    'environment' => '',
    'mountPoints' => '',
    'readonlyRootFilesystem' => '',
    'privileged' => '',
    'ulimits' => '',
    'user' => '',
    'instanceType' => '',
    'resourceRequirements' => '',
    'linuxParameters' => '',
    'logConfiguration' => '',
    'secrets' => '',
    'networkConfiguration' => '',
    'fargatePlatformConfiguration' => '',
    'ephemeralStorage' => ''
  ],
  'nodeProperties' => [
    'numNodes' => '',
    'mainNode' => '',
    'nodeRangeProperties' => ''
  ],
  'retryStrategy' => [
    'attempts' => '',
    'evaluateOnExit' => ''
  ],
  'propagateTags' => null,
  'timeout' => [
    'attemptDurationSeconds' => ''
  ],
  'tags' => [
    
  ],
  'platformCapabilities' => [
    
  ],
  'eksProperties' => [
    'podProperties' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobDefinitionName' => '',
  'type' => '',
  'parameters' => [
    
  ],
  'schedulingPriority' => 0,
  'containerProperties' => [
    'image' => '',
    'vcpus' => '',
    'memory' => '',
    'command' => '',
    'jobRoleArn' => '',
    'executionRoleArn' => '',
    'volumes' => '',
    'environment' => '',
    'mountPoints' => '',
    'readonlyRootFilesystem' => '',
    'privileged' => '',
    'ulimits' => '',
    'user' => '',
    'instanceType' => '',
    'resourceRequirements' => '',
    'linuxParameters' => '',
    'logConfiguration' => '',
    'secrets' => '',
    'networkConfiguration' => '',
    'fargatePlatformConfiguration' => '',
    'ephemeralStorage' => ''
  ],
  'nodeProperties' => [
    'numNodes' => '',
    'mainNode' => '',
    'nodeRangeProperties' => ''
  ],
  'retryStrategy' => [
    'attempts' => '',
    'evaluateOnExit' => ''
  ],
  'propagateTags' => null,
  'timeout' => [
    'attemptDurationSeconds' => ''
  ],
  'tags' => [
    
  ],
  'platformCapabilities' => [
    
  ],
  'eksProperties' => [
    'podProperties' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/registerjobdefinition');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/registerjobdefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinitionName": "",
  "type": "",
  "parameters": {},
  "schedulingPriority": 0,
  "containerProperties": {
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  },
  "nodeProperties": {
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "platformCapabilities": [],
  "eksProperties": {
    "podProperties": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/registerjobdefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobDefinitionName": "",
  "type": "",
  "parameters": {},
  "schedulingPriority": 0,
  "containerProperties": {
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  },
  "nodeProperties": {
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "platformCapabilities": [],
  "eksProperties": {
    "podProperties": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/registerjobdefinition", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/registerjobdefinition"

payload = {
    "jobDefinitionName": "",
    "type": "",
    "parameters": {},
    "schedulingPriority": 0,
    "containerProperties": {
        "image": "",
        "vcpus": "",
        "memory": "",
        "command": "",
        "jobRoleArn": "",
        "executionRoleArn": "",
        "volumes": "",
        "environment": "",
        "mountPoints": "",
        "readonlyRootFilesystem": "",
        "privileged": "",
        "ulimits": "",
        "user": "",
        "instanceType": "",
        "resourceRequirements": "",
        "linuxParameters": "",
        "logConfiguration": "",
        "secrets": "",
        "networkConfiguration": "",
        "fargatePlatformConfiguration": "",
        "ephemeralStorage": ""
    },
    "nodeProperties": {
        "numNodes": "",
        "mainNode": "",
        "nodeRangeProperties": ""
    },
    "retryStrategy": {
        "attempts": "",
        "evaluateOnExit": ""
    },
    "propagateTags": False,
    "timeout": { "attemptDurationSeconds": "" },
    "tags": {},
    "platformCapabilities": [],
    "eksProperties": { "podProperties": "" }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/registerjobdefinition"

payload <- "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/registerjobdefinition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/registerjobdefinition') do |req|
  req.body = "{\n  \"jobDefinitionName\": \"\",\n  \"type\": \"\",\n  \"parameters\": {},\n  \"schedulingPriority\": 0,\n  \"containerProperties\": {\n    \"image\": \"\",\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"jobRoleArn\": \"\",\n    \"executionRoleArn\": \"\",\n    \"volumes\": \"\",\n    \"environment\": \"\",\n    \"mountPoints\": \"\",\n    \"readonlyRootFilesystem\": \"\",\n    \"privileged\": \"\",\n    \"ulimits\": \"\",\n    \"user\": \"\",\n    \"instanceType\": \"\",\n    \"resourceRequirements\": \"\",\n    \"linuxParameters\": \"\",\n    \"logConfiguration\": \"\",\n    \"secrets\": \"\",\n    \"networkConfiguration\": \"\",\n    \"fargatePlatformConfiguration\": \"\",\n    \"ephemeralStorage\": \"\"\n  },\n  \"nodeProperties\": {\n    \"numNodes\": \"\",\n    \"mainNode\": \"\",\n    \"nodeRangeProperties\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"platformCapabilities\": [],\n  \"eksProperties\": {\n    \"podProperties\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/registerjobdefinition";

    let payload = json!({
        "jobDefinitionName": "",
        "type": "",
        "parameters": json!({}),
        "schedulingPriority": 0,
        "containerProperties": json!({
            "image": "",
            "vcpus": "",
            "memory": "",
            "command": "",
            "jobRoleArn": "",
            "executionRoleArn": "",
            "volumes": "",
            "environment": "",
            "mountPoints": "",
            "readonlyRootFilesystem": "",
            "privileged": "",
            "ulimits": "",
            "user": "",
            "instanceType": "",
            "resourceRequirements": "",
            "linuxParameters": "",
            "logConfiguration": "",
            "secrets": "",
            "networkConfiguration": "",
            "fargatePlatformConfiguration": "",
            "ephemeralStorage": ""
        }),
        "nodeProperties": json!({
            "numNodes": "",
            "mainNode": "",
            "nodeRangeProperties": ""
        }),
        "retryStrategy": json!({
            "attempts": "",
            "evaluateOnExit": ""
        }),
        "propagateTags": false,
        "timeout": json!({"attemptDurationSeconds": ""}),
        "tags": json!({}),
        "platformCapabilities": (),
        "eksProperties": json!({"podProperties": ""})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobDefinitionName": "",
  "type": "",
  "parameters": {},
  "schedulingPriority": 0,
  "containerProperties": {
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  },
  "nodeProperties": {
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "platformCapabilities": [],
  "eksProperties": {
    "podProperties": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/registerjobdefinition \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobDefinitionName": "",\n  "type": "",\n  "parameters": {},\n  "schedulingPriority": 0,\n  "containerProperties": {\n    "image": "",\n    "vcpus": "",\n    "memory": "",\n    "command": "",\n    "jobRoleArn": "",\n    "executionRoleArn": "",\n    "volumes": "",\n    "environment": "",\n    "mountPoints": "",\n    "readonlyRootFilesystem": "",\n    "privileged": "",\n    "ulimits": "",\n    "user": "",\n    "instanceType": "",\n    "resourceRequirements": "",\n    "linuxParameters": "",\n    "logConfiguration": "",\n    "secrets": "",\n    "networkConfiguration": "",\n    "fargatePlatformConfiguration": "",\n    "ephemeralStorage": ""\n  },\n  "nodeProperties": {\n    "numNodes": "",\n    "mainNode": "",\n    "nodeRangeProperties": ""\n  },\n  "retryStrategy": {\n    "attempts": "",\n    "evaluateOnExit": ""\n  },\n  "propagateTags": false,\n  "timeout": {\n    "attemptDurationSeconds": ""\n  },\n  "tags": {},\n  "platformCapabilities": [],\n  "eksProperties": {\n    "podProperties": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/registerjobdefinition

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobDefinitionName": "",
  "type": "",
  "parameters": [],
  "schedulingPriority": 0,
  "containerProperties": [
    "image": "",
    "vcpus": "",
    "memory": "",
    "command": "",
    "jobRoleArn": "",
    "executionRoleArn": "",
    "volumes": "",
    "environment": "",
    "mountPoints": "",
    "readonlyRootFilesystem": "",
    "privileged": "",
    "ulimits": "",
    "user": "",
    "instanceType": "",
    "resourceRequirements": "",
    "linuxParameters": "",
    "logConfiguration": "",
    "secrets": "",
    "networkConfiguration": "",
    "fargatePlatformConfiguration": "",
    "ephemeralStorage": ""
  ],
  "nodeProperties": [
    "numNodes": "",
    "mainNode": "",
    "nodeRangeProperties": ""
  ],
  "retryStrategy": [
    "attempts": "",
    "evaluateOnExit": ""
  ],
  "propagateTags": false,
  "timeout": ["attemptDurationSeconds": ""],
  "tags": [],
  "platformCapabilities": [],
  "eksProperties": ["podProperties": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/registerjobdefinition")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/submitjob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/submitjob" {:content-type :json
                                                         :form-params {:jobName ""
                                                                       :jobQueue ""
                                                                       :shareIdentifier ""
                                                                       :schedulingPriorityOverride 0
                                                                       :arrayProperties {:size ""}
                                                                       :dependsOn [{:jobId ""
                                                                                    :type ""}]
                                                                       :jobDefinition ""
                                                                       :parameters {}
                                                                       :containerOverrides {:vcpus ""
                                                                                            :memory ""
                                                                                            :command ""
                                                                                            :instanceType ""
                                                                                            :environment ""
                                                                                            :resourceRequirements ""}
                                                                       :nodeOverrides {:numNodes ""
                                                                                       :nodePropertyOverrides ""}
                                                                       :retryStrategy {:attempts ""
                                                                                       :evaluateOnExit ""}
                                                                       :propagateTags false
                                                                       :timeout {:attemptDurationSeconds ""}
                                                                       :tags {}
                                                                       :eksPropertiesOverride {:podProperties ""}}})

require "http/client"

url = "{{baseUrl}}/v1/submitjob"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/submitjob"),
    Content = new StringContent("{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/submitjob");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/submitjob"

	payload := strings.NewReader("{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/submitjob HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 716

{
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": {
    "size": ""
  },
  "dependsOn": [
    {
      "jobId": "",
      "type": ""
    }
  ],
  "jobDefinition": "",
  "parameters": {},
  "containerOverrides": {
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  },
  "nodeOverrides": {
    "numNodes": "",
    "nodePropertyOverrides": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "eksPropertiesOverride": {
    "podProperties": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/submitjob")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/submitjob"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/submitjob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/submitjob")
  .header("content-type", "application/json")
  .body("{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  jobName: '',
  jobQueue: '',
  shareIdentifier: '',
  schedulingPriorityOverride: 0,
  arrayProperties: {
    size: ''
  },
  dependsOn: [
    {
      jobId: '',
      type: ''
    }
  ],
  jobDefinition: '',
  parameters: {},
  containerOverrides: {
    vcpus: '',
    memory: '',
    command: '',
    instanceType: '',
    environment: '',
    resourceRequirements: ''
  },
  nodeOverrides: {
    numNodes: '',
    nodePropertyOverrides: ''
  },
  retryStrategy: {
    attempts: '',
    evaluateOnExit: ''
  },
  propagateTags: false,
  timeout: {
    attemptDurationSeconds: ''
  },
  tags: {},
  eksPropertiesOverride: {
    podProperties: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/submitjob');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/submitjob',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobQueue: '',
    shareIdentifier: '',
    schedulingPriorityOverride: 0,
    arrayProperties: {size: ''},
    dependsOn: [{jobId: '', type: ''}],
    jobDefinition: '',
    parameters: {},
    containerOverrides: {
      vcpus: '',
      memory: '',
      command: '',
      instanceType: '',
      environment: '',
      resourceRequirements: ''
    },
    nodeOverrides: {numNodes: '', nodePropertyOverrides: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    eksPropertiesOverride: {podProperties: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/submitjob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobQueue":"","shareIdentifier":"","schedulingPriorityOverride":0,"arrayProperties":{"size":""},"dependsOn":[{"jobId":"","type":""}],"jobDefinition":"","parameters":{},"containerOverrides":{"vcpus":"","memory":"","command":"","instanceType":"","environment":"","resourceRequirements":""},"nodeOverrides":{"numNodes":"","nodePropertyOverrides":""},"retryStrategy":{"attempts":"","evaluateOnExit":""},"propagateTags":false,"timeout":{"attemptDurationSeconds":""},"tags":{},"eksPropertiesOverride":{"podProperties":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/submitjob',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobName": "",\n  "jobQueue": "",\n  "shareIdentifier": "",\n  "schedulingPriorityOverride": 0,\n  "arrayProperties": {\n    "size": ""\n  },\n  "dependsOn": [\n    {\n      "jobId": "",\n      "type": ""\n    }\n  ],\n  "jobDefinition": "",\n  "parameters": {},\n  "containerOverrides": {\n    "vcpus": "",\n    "memory": "",\n    "command": "",\n    "instanceType": "",\n    "environment": "",\n    "resourceRequirements": ""\n  },\n  "nodeOverrides": {\n    "numNodes": "",\n    "nodePropertyOverrides": ""\n  },\n  "retryStrategy": {\n    "attempts": "",\n    "evaluateOnExit": ""\n  },\n  "propagateTags": false,\n  "timeout": {\n    "attemptDurationSeconds": ""\n  },\n  "tags": {},\n  "eksPropertiesOverride": {\n    "podProperties": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/submitjob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/submitjob',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobName: '',
  jobQueue: '',
  shareIdentifier: '',
  schedulingPriorityOverride: 0,
  arrayProperties: {size: ''},
  dependsOn: [{jobId: '', type: ''}],
  jobDefinition: '',
  parameters: {},
  containerOverrides: {
    vcpus: '',
    memory: '',
    command: '',
    instanceType: '',
    environment: '',
    resourceRequirements: ''
  },
  nodeOverrides: {numNodes: '', nodePropertyOverrides: ''},
  retryStrategy: {attempts: '', evaluateOnExit: ''},
  propagateTags: false,
  timeout: {attemptDurationSeconds: ''},
  tags: {},
  eksPropertiesOverride: {podProperties: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/submitjob',
  headers: {'content-type': 'application/json'},
  body: {
    jobName: '',
    jobQueue: '',
    shareIdentifier: '',
    schedulingPriorityOverride: 0,
    arrayProperties: {size: ''},
    dependsOn: [{jobId: '', type: ''}],
    jobDefinition: '',
    parameters: {},
    containerOverrides: {
      vcpus: '',
      memory: '',
      command: '',
      instanceType: '',
      environment: '',
      resourceRequirements: ''
    },
    nodeOverrides: {numNodes: '', nodePropertyOverrides: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    eksPropertiesOverride: {podProperties: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/submitjob');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobName: '',
  jobQueue: '',
  shareIdentifier: '',
  schedulingPriorityOverride: 0,
  arrayProperties: {
    size: ''
  },
  dependsOn: [
    {
      jobId: '',
      type: ''
    }
  ],
  jobDefinition: '',
  parameters: {},
  containerOverrides: {
    vcpus: '',
    memory: '',
    command: '',
    instanceType: '',
    environment: '',
    resourceRequirements: ''
  },
  nodeOverrides: {
    numNodes: '',
    nodePropertyOverrides: ''
  },
  retryStrategy: {
    attempts: '',
    evaluateOnExit: ''
  },
  propagateTags: false,
  timeout: {
    attemptDurationSeconds: ''
  },
  tags: {},
  eksPropertiesOverride: {
    podProperties: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/submitjob',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobQueue: '',
    shareIdentifier: '',
    schedulingPriorityOverride: 0,
    arrayProperties: {size: ''},
    dependsOn: [{jobId: '', type: ''}],
    jobDefinition: '',
    parameters: {},
    containerOverrides: {
      vcpus: '',
      memory: '',
      command: '',
      instanceType: '',
      environment: '',
      resourceRequirements: ''
    },
    nodeOverrides: {numNodes: '', nodePropertyOverrides: ''},
    retryStrategy: {attempts: '', evaluateOnExit: ''},
    propagateTags: false,
    timeout: {attemptDurationSeconds: ''},
    tags: {},
    eksPropertiesOverride: {podProperties: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/submitjob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobQueue":"","shareIdentifier":"","schedulingPriorityOverride":0,"arrayProperties":{"size":""},"dependsOn":[{"jobId":"","type":""}],"jobDefinition":"","parameters":{},"containerOverrides":{"vcpus":"","memory":"","command":"","instanceType":"","environment":"","resourceRequirements":""},"nodeOverrides":{"numNodes":"","nodePropertyOverrides":""},"retryStrategy":{"attempts":"","evaluateOnExit":""},"propagateTags":false,"timeout":{"attemptDurationSeconds":""},"tags":{},"eksPropertiesOverride":{"podProperties":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobName": @"",
                              @"jobQueue": @"",
                              @"shareIdentifier": @"",
                              @"schedulingPriorityOverride": @0,
                              @"arrayProperties": @{ @"size": @"" },
                              @"dependsOn": @[ @{ @"jobId": @"", @"type": @"" } ],
                              @"jobDefinition": @"",
                              @"parameters": @{  },
                              @"containerOverrides": @{ @"vcpus": @"", @"memory": @"", @"command": @"", @"instanceType": @"", @"environment": @"", @"resourceRequirements": @"" },
                              @"nodeOverrides": @{ @"numNodes": @"", @"nodePropertyOverrides": @"" },
                              @"retryStrategy": @{ @"attempts": @"", @"evaluateOnExit": @"" },
                              @"propagateTags": @NO,
                              @"timeout": @{ @"attemptDurationSeconds": @"" },
                              @"tags": @{  },
                              @"eksPropertiesOverride": @{ @"podProperties": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/submitjob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/submitjob" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/submitjob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobName' => '',
    'jobQueue' => '',
    'shareIdentifier' => '',
    'schedulingPriorityOverride' => 0,
    'arrayProperties' => [
        'size' => ''
    ],
    'dependsOn' => [
        [
                'jobId' => '',
                'type' => ''
        ]
    ],
    'jobDefinition' => '',
    'parameters' => [
        
    ],
    'containerOverrides' => [
        'vcpus' => '',
        'memory' => '',
        'command' => '',
        'instanceType' => '',
        'environment' => '',
        'resourceRequirements' => ''
    ],
    'nodeOverrides' => [
        'numNodes' => '',
        'nodePropertyOverrides' => ''
    ],
    'retryStrategy' => [
        'attempts' => '',
        'evaluateOnExit' => ''
    ],
    'propagateTags' => null,
    'timeout' => [
        'attemptDurationSeconds' => ''
    ],
    'tags' => [
        
    ],
    'eksPropertiesOverride' => [
        'podProperties' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/submitjob', [
  'body' => '{
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": {
    "size": ""
  },
  "dependsOn": [
    {
      "jobId": "",
      "type": ""
    }
  ],
  "jobDefinition": "",
  "parameters": {},
  "containerOverrides": {
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  },
  "nodeOverrides": {
    "numNodes": "",
    "nodePropertyOverrides": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "eksPropertiesOverride": {
    "podProperties": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/submitjob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobName' => '',
  'jobQueue' => '',
  'shareIdentifier' => '',
  'schedulingPriorityOverride' => 0,
  'arrayProperties' => [
    'size' => ''
  ],
  'dependsOn' => [
    [
        'jobId' => '',
        'type' => ''
    ]
  ],
  'jobDefinition' => '',
  'parameters' => [
    
  ],
  'containerOverrides' => [
    'vcpus' => '',
    'memory' => '',
    'command' => '',
    'instanceType' => '',
    'environment' => '',
    'resourceRequirements' => ''
  ],
  'nodeOverrides' => [
    'numNodes' => '',
    'nodePropertyOverrides' => ''
  ],
  'retryStrategy' => [
    'attempts' => '',
    'evaluateOnExit' => ''
  ],
  'propagateTags' => null,
  'timeout' => [
    'attemptDurationSeconds' => ''
  ],
  'tags' => [
    
  ],
  'eksPropertiesOverride' => [
    'podProperties' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobName' => '',
  'jobQueue' => '',
  'shareIdentifier' => '',
  'schedulingPriorityOverride' => 0,
  'arrayProperties' => [
    'size' => ''
  ],
  'dependsOn' => [
    [
        'jobId' => '',
        'type' => ''
    ]
  ],
  'jobDefinition' => '',
  'parameters' => [
    
  ],
  'containerOverrides' => [
    'vcpus' => '',
    'memory' => '',
    'command' => '',
    'instanceType' => '',
    'environment' => '',
    'resourceRequirements' => ''
  ],
  'nodeOverrides' => [
    'numNodes' => '',
    'nodePropertyOverrides' => ''
  ],
  'retryStrategy' => [
    'attempts' => '',
    'evaluateOnExit' => ''
  ],
  'propagateTags' => null,
  'timeout' => [
    'attemptDurationSeconds' => ''
  ],
  'tags' => [
    
  ],
  'eksPropertiesOverride' => [
    'podProperties' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/submitjob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/submitjob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": {
    "size": ""
  },
  "dependsOn": [
    {
      "jobId": "",
      "type": ""
    }
  ],
  "jobDefinition": "",
  "parameters": {},
  "containerOverrides": {
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  },
  "nodeOverrides": {
    "numNodes": "",
    "nodePropertyOverrides": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "eksPropertiesOverride": {
    "podProperties": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/submitjob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": {
    "size": ""
  },
  "dependsOn": [
    {
      "jobId": "",
      "type": ""
    }
  ],
  "jobDefinition": "",
  "parameters": {},
  "containerOverrides": {
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  },
  "nodeOverrides": {
    "numNodes": "",
    "nodePropertyOverrides": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "eksPropertiesOverride": {
    "podProperties": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/submitjob", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/submitjob"

payload = {
    "jobName": "",
    "jobQueue": "",
    "shareIdentifier": "",
    "schedulingPriorityOverride": 0,
    "arrayProperties": { "size": "" },
    "dependsOn": [
        {
            "jobId": "",
            "type": ""
        }
    ],
    "jobDefinition": "",
    "parameters": {},
    "containerOverrides": {
        "vcpus": "",
        "memory": "",
        "command": "",
        "instanceType": "",
        "environment": "",
        "resourceRequirements": ""
    },
    "nodeOverrides": {
        "numNodes": "",
        "nodePropertyOverrides": ""
    },
    "retryStrategy": {
        "attempts": "",
        "evaluateOnExit": ""
    },
    "propagateTags": False,
    "timeout": { "attemptDurationSeconds": "" },
    "tags": {},
    "eksPropertiesOverride": { "podProperties": "" }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/submitjob"

payload <- "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/submitjob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/submitjob') do |req|
  req.body = "{\n  \"jobName\": \"\",\n  \"jobQueue\": \"\",\n  \"shareIdentifier\": \"\",\n  \"schedulingPriorityOverride\": 0,\n  \"arrayProperties\": {\n    \"size\": \"\"\n  },\n  \"dependsOn\": [\n    {\n      \"jobId\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"jobDefinition\": \"\",\n  \"parameters\": {},\n  \"containerOverrides\": {\n    \"vcpus\": \"\",\n    \"memory\": \"\",\n    \"command\": \"\",\n    \"instanceType\": \"\",\n    \"environment\": \"\",\n    \"resourceRequirements\": \"\"\n  },\n  \"nodeOverrides\": {\n    \"numNodes\": \"\",\n    \"nodePropertyOverrides\": \"\"\n  },\n  \"retryStrategy\": {\n    \"attempts\": \"\",\n    \"evaluateOnExit\": \"\"\n  },\n  \"propagateTags\": false,\n  \"timeout\": {\n    \"attemptDurationSeconds\": \"\"\n  },\n  \"tags\": {},\n  \"eksPropertiesOverride\": {\n    \"podProperties\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/submitjob";

    let payload = json!({
        "jobName": "",
        "jobQueue": "",
        "shareIdentifier": "",
        "schedulingPriorityOverride": 0,
        "arrayProperties": json!({"size": ""}),
        "dependsOn": (
            json!({
                "jobId": "",
                "type": ""
            })
        ),
        "jobDefinition": "",
        "parameters": json!({}),
        "containerOverrides": json!({
            "vcpus": "",
            "memory": "",
            "command": "",
            "instanceType": "",
            "environment": "",
            "resourceRequirements": ""
        }),
        "nodeOverrides": json!({
            "numNodes": "",
            "nodePropertyOverrides": ""
        }),
        "retryStrategy": json!({
            "attempts": "",
            "evaluateOnExit": ""
        }),
        "propagateTags": false,
        "timeout": json!({"attemptDurationSeconds": ""}),
        "tags": json!({}),
        "eksPropertiesOverride": json!({"podProperties": ""})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": {
    "size": ""
  },
  "dependsOn": [
    {
      "jobId": "",
      "type": ""
    }
  ],
  "jobDefinition": "",
  "parameters": {},
  "containerOverrides": {
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  },
  "nodeOverrides": {
    "numNodes": "",
    "nodePropertyOverrides": ""
  },
  "retryStrategy": {
    "attempts": "",
    "evaluateOnExit": ""
  },
  "propagateTags": false,
  "timeout": {
    "attemptDurationSeconds": ""
  },
  "tags": {},
  "eksPropertiesOverride": {
    "podProperties": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/submitjob \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobName": "",\n  "jobQueue": "",\n  "shareIdentifier": "",\n  "schedulingPriorityOverride": 0,\n  "arrayProperties": {\n    "size": ""\n  },\n  "dependsOn": [\n    {\n      "jobId": "",\n      "type": ""\n    }\n  ],\n  "jobDefinition": "",\n  "parameters": {},\n  "containerOverrides": {\n    "vcpus": "",\n    "memory": "",\n    "command": "",\n    "instanceType": "",\n    "environment": "",\n    "resourceRequirements": ""\n  },\n  "nodeOverrides": {\n    "numNodes": "",\n    "nodePropertyOverrides": ""\n  },\n  "retryStrategy": {\n    "attempts": "",\n    "evaluateOnExit": ""\n  },\n  "propagateTags": false,\n  "timeout": {\n    "attemptDurationSeconds": ""\n  },\n  "tags": {},\n  "eksPropertiesOverride": {\n    "podProperties": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/submitjob

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobName": "",
  "jobQueue": "",
  "shareIdentifier": "",
  "schedulingPriorityOverride": 0,
  "arrayProperties": ["size": ""],
  "dependsOn": [
    [
      "jobId": "",
      "type": ""
    ]
  ],
  "jobDefinition": "",
  "parameters": [],
  "containerOverrides": [
    "vcpus": "",
    "memory": "",
    "command": "",
    "instanceType": "",
    "environment": "",
    "resourceRequirements": ""
  ],
  "nodeOverrides": [
    "numNodes": "",
    "nodePropertyOverrides": ""
  ],
  "retryStrategy": [
    "attempts": "",
    "evaluateOnExit": ""
  ],
  "propagateTags": false,
  "timeout": ["attemptDurationSeconds": ""],
  "tags": [],
  "eksPropertiesOverride": ["podProperties": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/submitjob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/tags/:resourceArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/tags/:resourceArn" {:content-type :json
                                                                 :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/v1/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/tags/:resourceArn"),
    Content = new StringContent("{\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/tags/:resourceArn"

	payload := strings.NewReader("{\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/tags/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/tags/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/tags/:resourceArn',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/tags/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/tags/:resourceArn');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/tags/:resourceArn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/tags/:resourceArn"

payload <- "{\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/tags/:resourceArn') do |req|
  req.body = "{\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/tags/:resourceArn";

    let payload = json!({"tags": json!({})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/v1/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/v1/tags/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/terminatejob");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/terminatejob" {:content-type :json
                                                            :form-params {:jobId ""
                                                                          :reason ""}})

require "http/client"

url = "{{baseUrl}}/v1/terminatejob"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/terminatejob"),
    Content = new StringContent("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/terminatejob");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/terminatejob"

	payload := strings.NewReader("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/terminatejob HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "jobId": "",
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/terminatejob")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/terminatejob"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/terminatejob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/terminatejob")
  .header("content-type", "application/json")
  .body("{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobId: '',
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/terminatejob');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/terminatejob',
  headers: {'content-type': 'application/json'},
  data: {jobId: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/terminatejob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobId":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/terminatejob',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobId": "",\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/terminatejob")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/terminatejob',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({jobId: '', reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/terminatejob',
  headers: {'content-type': 'application/json'},
  body: {jobId: '', reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/terminatejob');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobId: '',
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/terminatejob',
  headers: {'content-type': 'application/json'},
  data: {jobId: '', reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/terminatejob';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobId":"","reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobId": @"",
                              @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/terminatejob"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/terminatejob" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/terminatejob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobId' => '',
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/terminatejob', [
  'body' => '{
  "jobId": "",
  "reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/terminatejob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobId' => '',
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobId' => '',
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/v1/terminatejob');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/terminatejob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobId": "",
  "reason": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/terminatejob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobId": "",
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/terminatejob", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/terminatejob"

payload = {
    "jobId": "",
    "reason": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/terminatejob"

payload <- "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/terminatejob")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/terminatejob') do |req|
  req.body = "{\n  \"jobId\": \"\",\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/terminatejob";

    let payload = json!({
        "jobId": "",
        "reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobId": "",
  "reason": ""
}' |  \
  http POST {{baseUrl}}/v1/terminatejob \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobId": "",\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/v1/terminatejob

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobId": "",
  "reason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/terminatejob")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/v1/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/v1/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/tags/:resourceArn?tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/v1/tags/:resourceArn#tagKeys');

req.query({
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/v1/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/v1/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/v1/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/v1/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/v1/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/tags/:resourceArn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/updatecomputeenvironment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/updatecomputeenvironment" {:content-type :json
                                                                        :form-params {:computeEnvironment ""
                                                                                      :state ""
                                                                                      :unmanagedvCpus 0
                                                                                      :computeResources {:minvCpus ""
                                                                                                         :maxvCpus ""
                                                                                                         :desiredvCpus ""
                                                                                                         :subnets ""
                                                                                                         :securityGroupIds ""
                                                                                                         :allocationStrategy ""
                                                                                                         :instanceTypes ""
                                                                                                         :ec2KeyPair ""
                                                                                                         :instanceRole ""
                                                                                                         :tags ""
                                                                                                         :placementGroup ""
                                                                                                         :bidPercentage ""
                                                                                                         :launchTemplate ""
                                                                                                         :ec2Configuration ""
                                                                                                         :updateToLatestImageVersion ""
                                                                                                         :type ""
                                                                                                         :imageId ""}
                                                                                      :serviceRole ""
                                                                                      :updatePolicy {:terminateJobsOnUpdate ""
                                                                                                     :jobExecutionTimeoutMinutes ""}}})

require "http/client"

url = "{{baseUrl}}/v1/updatecomputeenvironment"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/updatecomputeenvironment"),
    Content = new StringContent("{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/updatecomputeenvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/updatecomputeenvironment"

	payload := strings.NewReader("{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/updatecomputeenvironment HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 618

{
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  },
  "serviceRole": "",
  "updatePolicy": {
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/updatecomputeenvironment")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/updatecomputeenvironment"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/updatecomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/updatecomputeenvironment")
  .header("content-type", "application/json")
  .body("{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  computeEnvironment: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    subnets: '',
    securityGroupIds: '',
    allocationStrategy: '',
    instanceTypes: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    launchTemplate: '',
    ec2Configuration: '',
    updateToLatestImageVersion: '',
    type: '',
    imageId: ''
  },
  serviceRole: '',
  updatePolicy: {
    terminateJobsOnUpdate: '',
    jobExecutionTimeoutMinutes: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/updatecomputeenvironment');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatecomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {
    computeEnvironment: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      subnets: '',
      securityGroupIds: '',
      allocationStrategy: '',
      instanceTypes: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      launchTemplate: '',
      ec2Configuration: '',
      updateToLatestImageVersion: '',
      type: '',
      imageId: ''
    },
    serviceRole: '',
    updatePolicy: {terminateJobsOnUpdate: '', jobExecutionTimeoutMinutes: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/updatecomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironment":"","state":"","unmanagedvCpus":0,"computeResources":{"minvCpus":"","maxvCpus":"","desiredvCpus":"","subnets":"","securityGroupIds":"","allocationStrategy":"","instanceTypes":"","ec2KeyPair":"","instanceRole":"","tags":"","placementGroup":"","bidPercentage":"","launchTemplate":"","ec2Configuration":"","updateToLatestImageVersion":"","type":"","imageId":""},"serviceRole":"","updatePolicy":{"terminateJobsOnUpdate":"","jobExecutionTimeoutMinutes":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/updatecomputeenvironment',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "computeEnvironment": "",\n  "state": "",\n  "unmanagedvCpus": 0,\n  "computeResources": {\n    "minvCpus": "",\n    "maxvCpus": "",\n    "desiredvCpus": "",\n    "subnets": "",\n    "securityGroupIds": "",\n    "allocationStrategy": "",\n    "instanceTypes": "",\n    "ec2KeyPair": "",\n    "instanceRole": "",\n    "tags": "",\n    "placementGroup": "",\n    "bidPercentage": "",\n    "launchTemplate": "",\n    "ec2Configuration": "",\n    "updateToLatestImageVersion": "",\n    "type": "",\n    "imageId": ""\n  },\n  "serviceRole": "",\n  "updatePolicy": {\n    "terminateJobsOnUpdate": "",\n    "jobExecutionTimeoutMinutes": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/updatecomputeenvironment")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/updatecomputeenvironment',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  computeEnvironment: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    subnets: '',
    securityGroupIds: '',
    allocationStrategy: '',
    instanceTypes: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    launchTemplate: '',
    ec2Configuration: '',
    updateToLatestImageVersion: '',
    type: '',
    imageId: ''
  },
  serviceRole: '',
  updatePolicy: {terminateJobsOnUpdate: '', jobExecutionTimeoutMinutes: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatecomputeenvironment',
  headers: {'content-type': 'application/json'},
  body: {
    computeEnvironment: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      subnets: '',
      securityGroupIds: '',
      allocationStrategy: '',
      instanceTypes: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      launchTemplate: '',
      ec2Configuration: '',
      updateToLatestImageVersion: '',
      type: '',
      imageId: ''
    },
    serviceRole: '',
    updatePolicy: {terminateJobsOnUpdate: '', jobExecutionTimeoutMinutes: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/updatecomputeenvironment');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  computeEnvironment: '',
  state: '',
  unmanagedvCpus: 0,
  computeResources: {
    minvCpus: '',
    maxvCpus: '',
    desiredvCpus: '',
    subnets: '',
    securityGroupIds: '',
    allocationStrategy: '',
    instanceTypes: '',
    ec2KeyPair: '',
    instanceRole: '',
    tags: '',
    placementGroup: '',
    bidPercentage: '',
    launchTemplate: '',
    ec2Configuration: '',
    updateToLatestImageVersion: '',
    type: '',
    imageId: ''
  },
  serviceRole: '',
  updatePolicy: {
    terminateJobsOnUpdate: '',
    jobExecutionTimeoutMinutes: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatecomputeenvironment',
  headers: {'content-type': 'application/json'},
  data: {
    computeEnvironment: '',
    state: '',
    unmanagedvCpus: 0,
    computeResources: {
      minvCpus: '',
      maxvCpus: '',
      desiredvCpus: '',
      subnets: '',
      securityGroupIds: '',
      allocationStrategy: '',
      instanceTypes: '',
      ec2KeyPair: '',
      instanceRole: '',
      tags: '',
      placementGroup: '',
      bidPercentage: '',
      launchTemplate: '',
      ec2Configuration: '',
      updateToLatestImageVersion: '',
      type: '',
      imageId: ''
    },
    serviceRole: '',
    updatePolicy: {terminateJobsOnUpdate: '', jobExecutionTimeoutMinutes: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/updatecomputeenvironment';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"computeEnvironment":"","state":"","unmanagedvCpus":0,"computeResources":{"minvCpus":"","maxvCpus":"","desiredvCpus":"","subnets":"","securityGroupIds":"","allocationStrategy":"","instanceTypes":"","ec2KeyPair":"","instanceRole":"","tags":"","placementGroup":"","bidPercentage":"","launchTemplate":"","ec2Configuration":"","updateToLatestImageVersion":"","type":"","imageId":""},"serviceRole":"","updatePolicy":{"terminateJobsOnUpdate":"","jobExecutionTimeoutMinutes":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"computeEnvironment": @"",
                              @"state": @"",
                              @"unmanagedvCpus": @0,
                              @"computeResources": @{ @"minvCpus": @"", @"maxvCpus": @"", @"desiredvCpus": @"", @"subnets": @"", @"securityGroupIds": @"", @"allocationStrategy": @"", @"instanceTypes": @"", @"ec2KeyPair": @"", @"instanceRole": @"", @"tags": @"", @"placementGroup": @"", @"bidPercentage": @"", @"launchTemplate": @"", @"ec2Configuration": @"", @"updateToLatestImageVersion": @"", @"type": @"", @"imageId": @"" },
                              @"serviceRole": @"",
                              @"updatePolicy": @{ @"terminateJobsOnUpdate": @"", @"jobExecutionTimeoutMinutes": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/updatecomputeenvironment"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/updatecomputeenvironment" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/updatecomputeenvironment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'computeEnvironment' => '',
    'state' => '',
    'unmanagedvCpus' => 0,
    'computeResources' => [
        'minvCpus' => '',
        'maxvCpus' => '',
        'desiredvCpus' => '',
        'subnets' => '',
        'securityGroupIds' => '',
        'allocationStrategy' => '',
        'instanceTypes' => '',
        'ec2KeyPair' => '',
        'instanceRole' => '',
        'tags' => '',
        'placementGroup' => '',
        'bidPercentage' => '',
        'launchTemplate' => '',
        'ec2Configuration' => '',
        'updateToLatestImageVersion' => '',
        'type' => '',
        'imageId' => ''
    ],
    'serviceRole' => '',
    'updatePolicy' => [
        'terminateJobsOnUpdate' => '',
        'jobExecutionTimeoutMinutes' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/updatecomputeenvironment', [
  'body' => '{
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  },
  "serviceRole": "",
  "updatePolicy": {
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/updatecomputeenvironment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'computeEnvironment' => '',
  'state' => '',
  'unmanagedvCpus' => 0,
  'computeResources' => [
    'minvCpus' => '',
    'maxvCpus' => '',
    'desiredvCpus' => '',
    'subnets' => '',
    'securityGroupIds' => '',
    'allocationStrategy' => '',
    'instanceTypes' => '',
    'ec2KeyPair' => '',
    'instanceRole' => '',
    'tags' => '',
    'placementGroup' => '',
    'bidPercentage' => '',
    'launchTemplate' => '',
    'ec2Configuration' => '',
    'updateToLatestImageVersion' => '',
    'type' => '',
    'imageId' => ''
  ],
  'serviceRole' => '',
  'updatePolicy' => [
    'terminateJobsOnUpdate' => '',
    'jobExecutionTimeoutMinutes' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'computeEnvironment' => '',
  'state' => '',
  'unmanagedvCpus' => 0,
  'computeResources' => [
    'minvCpus' => '',
    'maxvCpus' => '',
    'desiredvCpus' => '',
    'subnets' => '',
    'securityGroupIds' => '',
    'allocationStrategy' => '',
    'instanceTypes' => '',
    'ec2KeyPair' => '',
    'instanceRole' => '',
    'tags' => '',
    'placementGroup' => '',
    'bidPercentage' => '',
    'launchTemplate' => '',
    'ec2Configuration' => '',
    'updateToLatestImageVersion' => '',
    'type' => '',
    'imageId' => ''
  ],
  'serviceRole' => '',
  'updatePolicy' => [
    'terminateJobsOnUpdate' => '',
    'jobExecutionTimeoutMinutes' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/updatecomputeenvironment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/updatecomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  },
  "serviceRole": "",
  "updatePolicy": {
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/updatecomputeenvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  },
  "serviceRole": "",
  "updatePolicy": {
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/updatecomputeenvironment", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/updatecomputeenvironment"

payload = {
    "computeEnvironment": "",
    "state": "",
    "unmanagedvCpus": 0,
    "computeResources": {
        "minvCpus": "",
        "maxvCpus": "",
        "desiredvCpus": "",
        "subnets": "",
        "securityGroupIds": "",
        "allocationStrategy": "",
        "instanceTypes": "",
        "ec2KeyPair": "",
        "instanceRole": "",
        "tags": "",
        "placementGroup": "",
        "bidPercentage": "",
        "launchTemplate": "",
        "ec2Configuration": "",
        "updateToLatestImageVersion": "",
        "type": "",
        "imageId": ""
    },
    "serviceRole": "",
    "updatePolicy": {
        "terminateJobsOnUpdate": "",
        "jobExecutionTimeoutMinutes": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/updatecomputeenvironment"

payload <- "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/updatecomputeenvironment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/updatecomputeenvironment') do |req|
  req.body = "{\n  \"computeEnvironment\": \"\",\n  \"state\": \"\",\n  \"unmanagedvCpus\": 0,\n  \"computeResources\": {\n    \"minvCpus\": \"\",\n    \"maxvCpus\": \"\",\n    \"desiredvCpus\": \"\",\n    \"subnets\": \"\",\n    \"securityGroupIds\": \"\",\n    \"allocationStrategy\": \"\",\n    \"instanceTypes\": \"\",\n    \"ec2KeyPair\": \"\",\n    \"instanceRole\": \"\",\n    \"tags\": \"\",\n    \"placementGroup\": \"\",\n    \"bidPercentage\": \"\",\n    \"launchTemplate\": \"\",\n    \"ec2Configuration\": \"\",\n    \"updateToLatestImageVersion\": \"\",\n    \"type\": \"\",\n    \"imageId\": \"\"\n  },\n  \"serviceRole\": \"\",\n  \"updatePolicy\": {\n    \"terminateJobsOnUpdate\": \"\",\n    \"jobExecutionTimeoutMinutes\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/updatecomputeenvironment";

    let payload = json!({
        "computeEnvironment": "",
        "state": "",
        "unmanagedvCpus": 0,
        "computeResources": json!({
            "minvCpus": "",
            "maxvCpus": "",
            "desiredvCpus": "",
            "subnets": "",
            "securityGroupIds": "",
            "allocationStrategy": "",
            "instanceTypes": "",
            "ec2KeyPair": "",
            "instanceRole": "",
            "tags": "",
            "placementGroup": "",
            "bidPercentage": "",
            "launchTemplate": "",
            "ec2Configuration": "",
            "updateToLatestImageVersion": "",
            "type": "",
            "imageId": ""
        }),
        "serviceRole": "",
        "updatePolicy": json!({
            "terminateJobsOnUpdate": "",
            "jobExecutionTimeoutMinutes": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": {
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  },
  "serviceRole": "",
  "updatePolicy": {
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/updatecomputeenvironment \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "computeEnvironment": "",\n  "state": "",\n  "unmanagedvCpus": 0,\n  "computeResources": {\n    "minvCpus": "",\n    "maxvCpus": "",\n    "desiredvCpus": "",\n    "subnets": "",\n    "securityGroupIds": "",\n    "allocationStrategy": "",\n    "instanceTypes": "",\n    "ec2KeyPair": "",\n    "instanceRole": "",\n    "tags": "",\n    "placementGroup": "",\n    "bidPercentage": "",\n    "launchTemplate": "",\n    "ec2Configuration": "",\n    "updateToLatestImageVersion": "",\n    "type": "",\n    "imageId": ""\n  },\n  "serviceRole": "",\n  "updatePolicy": {\n    "terminateJobsOnUpdate": "",\n    "jobExecutionTimeoutMinutes": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/updatecomputeenvironment

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "computeEnvironment": "",
  "state": "",
  "unmanagedvCpus": 0,
  "computeResources": [
    "minvCpus": "",
    "maxvCpus": "",
    "desiredvCpus": "",
    "subnets": "",
    "securityGroupIds": "",
    "allocationStrategy": "",
    "instanceTypes": "",
    "ec2KeyPair": "",
    "instanceRole": "",
    "tags": "",
    "placementGroup": "",
    "bidPercentage": "",
    "launchTemplate": "",
    "ec2Configuration": "",
    "updateToLatestImageVersion": "",
    "type": "",
    "imageId": ""
  ],
  "serviceRole": "",
  "updatePolicy": [
    "terminateJobsOnUpdate": "",
    "jobExecutionTimeoutMinutes": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/updatecomputeenvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/updatejobqueue");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/updatejobqueue" {:content-type :json
                                                              :form-params {:jobQueue ""
                                                                            :state ""
                                                                            :schedulingPolicyArn ""
                                                                            :priority 0
                                                                            :computeEnvironmentOrder [{:order ""
                                                                                                       :computeEnvironment ""}]}})

require "http/client"

url = "{{baseUrl}}/v1/updatejobqueue"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/updatejobqueue"),
    Content = new StringContent("{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/updatejobqueue");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/updatejobqueue"

	payload := strings.NewReader("{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/updatejobqueue HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 179

{
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/updatejobqueue")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/updatejobqueue"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/updatejobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/updatejobqueue")
  .header("content-type", "application/json")
  .body("{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  jobQueue: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [
    {
      order: '',
      computeEnvironment: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/updatejobqueue');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatejobqueue',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueue: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/updatejobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":"","state":"","schedulingPolicyArn":"","priority":0,"computeEnvironmentOrder":[{"order":"","computeEnvironment":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/updatejobqueue',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobQueue": "",\n  "state": "",\n  "schedulingPolicyArn": "",\n  "priority": 0,\n  "computeEnvironmentOrder": [\n    {\n      "order": "",\n      "computeEnvironment": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/updatejobqueue")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/updatejobqueue',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  jobQueue: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [{order: '', computeEnvironment: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatejobqueue',
  headers: {'content-type': 'application/json'},
  body: {
    jobQueue: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/updatejobqueue');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobQueue: '',
  state: '',
  schedulingPolicyArn: '',
  priority: 0,
  computeEnvironmentOrder: [
    {
      order: '',
      computeEnvironment: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updatejobqueue',
  headers: {'content-type': 'application/json'},
  data: {
    jobQueue: '',
    state: '',
    schedulingPolicyArn: '',
    priority: 0,
    computeEnvironmentOrder: [{order: '', computeEnvironment: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/updatejobqueue';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobQueue":"","state":"","schedulingPolicyArn":"","priority":0,"computeEnvironmentOrder":[{"order":"","computeEnvironment":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobQueue": @"",
                              @"state": @"",
                              @"schedulingPolicyArn": @"",
                              @"priority": @0,
                              @"computeEnvironmentOrder": @[ @{ @"order": @"", @"computeEnvironment": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/updatejobqueue"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/updatejobqueue" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/updatejobqueue",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'jobQueue' => '',
    'state' => '',
    'schedulingPolicyArn' => '',
    'priority' => 0,
    'computeEnvironmentOrder' => [
        [
                'order' => '',
                'computeEnvironment' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/updatejobqueue', [
  'body' => '{
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/updatejobqueue');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobQueue' => '',
  'state' => '',
  'schedulingPolicyArn' => '',
  'priority' => 0,
  'computeEnvironmentOrder' => [
    [
        'order' => '',
        'computeEnvironment' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobQueue' => '',
  'state' => '',
  'schedulingPolicyArn' => '',
  'priority' => 0,
  'computeEnvironmentOrder' => [
    [
        'order' => '',
        'computeEnvironment' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/updatejobqueue');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/updatejobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/updatejobqueue' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/updatejobqueue", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/updatejobqueue"

payload = {
    "jobQueue": "",
    "state": "",
    "schedulingPolicyArn": "",
    "priority": 0,
    "computeEnvironmentOrder": [
        {
            "order": "",
            "computeEnvironment": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/updatejobqueue"

payload <- "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/updatejobqueue")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/updatejobqueue') do |req|
  req.body = "{\n  \"jobQueue\": \"\",\n  \"state\": \"\",\n  \"schedulingPolicyArn\": \"\",\n  \"priority\": 0,\n  \"computeEnvironmentOrder\": [\n    {\n      \"order\": \"\",\n      \"computeEnvironment\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/updatejobqueue";

    let payload = json!({
        "jobQueue": "",
        "state": "",
        "schedulingPolicyArn": "",
        "priority": 0,
        "computeEnvironmentOrder": (
            json!({
                "order": "",
                "computeEnvironment": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    {
      "order": "",
      "computeEnvironment": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/v1/updatejobqueue \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobQueue": "",\n  "state": "",\n  "schedulingPolicyArn": "",\n  "priority": 0,\n  "computeEnvironmentOrder": [\n    {\n      "order": "",\n      "computeEnvironment": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/v1/updatejobqueue

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobQueue": "",
  "state": "",
  "schedulingPolicyArn": "",
  "priority": 0,
  "computeEnvironmentOrder": [
    [
      "order": "",
      "computeEnvironment": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/updatejobqueue")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/v1/updateschedulingpolicy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/v1/updateschedulingpolicy" {:content-type :json
                                                                      :form-params {:arn ""
                                                                                    :fairsharePolicy {:shareDecaySeconds ""
                                                                                                      :computeReservation ""
                                                                                                      :shareDistribution ""}}})

require "http/client"

url = "{{baseUrl}}/v1/updateschedulingpolicy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/v1/updateschedulingpolicy"),
    Content = new StringContent("{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/v1/updateschedulingpolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/v1/updateschedulingpolicy"

	payload := strings.NewReader("{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/v1/updateschedulingpolicy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "arn": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/v1/updateschedulingpolicy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/v1/updateschedulingpolicy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/v1/updateschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/v1/updateschedulingpolicy")
  .header("content-type", "application/json")
  .body("{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  arn: '',
  fairsharePolicy: {
    shareDecaySeconds: '',
    computeReservation: '',
    shareDistribution: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/v1/updateschedulingpolicy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updateschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {
    arn: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/v1/updateschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arn":"","fairsharePolicy":{"shareDecaySeconds":"","computeReservation":"","shareDistribution":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/v1/updateschedulingpolicy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "arn": "",\n  "fairsharePolicy": {\n    "shareDecaySeconds": "",\n    "computeReservation": "",\n    "shareDistribution": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/v1/updateschedulingpolicy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/v1/updateschedulingpolicy',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  arn: '',
  fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updateschedulingpolicy',
  headers: {'content-type': 'application/json'},
  body: {
    arn: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/v1/updateschedulingpolicy');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  arn: '',
  fairsharePolicy: {
    shareDecaySeconds: '',
    computeReservation: '',
    shareDistribution: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/v1/updateschedulingpolicy',
  headers: {'content-type': 'application/json'},
  data: {
    arn: '',
    fairsharePolicy: {shareDecaySeconds: '', computeReservation: '', shareDistribution: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/v1/updateschedulingpolicy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"arn":"","fairsharePolicy":{"shareDecaySeconds":"","computeReservation":"","shareDistribution":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"arn": @"",
                              @"fairsharePolicy": @{ @"shareDecaySeconds": @"", @"computeReservation": @"", @"shareDistribution": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/v1/updateschedulingpolicy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/v1/updateschedulingpolicy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/v1/updateschedulingpolicy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'arn' => '',
    'fairsharePolicy' => [
        'shareDecaySeconds' => '',
        'computeReservation' => '',
        'shareDistribution' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/v1/updateschedulingpolicy', [
  'body' => '{
  "arn": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/v1/updateschedulingpolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'arn' => '',
  'fairsharePolicy' => [
    'shareDecaySeconds' => '',
    'computeReservation' => '',
    'shareDistribution' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'arn' => '',
  'fairsharePolicy' => [
    'shareDecaySeconds' => '',
    'computeReservation' => '',
    'shareDistribution' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/v1/updateschedulingpolicy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/v1/updateschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arn": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/v1/updateschedulingpolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "arn": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/v1/updateschedulingpolicy", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/v1/updateschedulingpolicy"

payload = {
    "arn": "",
    "fairsharePolicy": {
        "shareDecaySeconds": "",
        "computeReservation": "",
        "shareDistribution": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/v1/updateschedulingpolicy"

payload <- "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/v1/updateschedulingpolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/v1/updateschedulingpolicy') do |req|
  req.body = "{\n  \"arn\": \"\",\n  \"fairsharePolicy\": {\n    \"shareDecaySeconds\": \"\",\n    \"computeReservation\": \"\",\n    \"shareDistribution\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/v1/updateschedulingpolicy";

    let payload = json!({
        "arn": "",
        "fairsharePolicy": json!({
            "shareDecaySeconds": "",
            "computeReservation": "",
            "shareDistribution": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "arn": "",
  "fairsharePolicy": {
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  }
}' |  \
  http POST {{baseUrl}}/v1/updateschedulingpolicy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "arn": "",\n  "fairsharePolicy": {\n    "shareDecaySeconds": "",\n    "computeReservation": "",\n    "shareDistribution": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/v1/updateschedulingpolicy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "arn": "",
  "fairsharePolicy": [
    "shareDecaySeconds": "",
    "computeReservation": "",
    "shareDistribution": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/v1/updateschedulingpolicy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()