CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:QualificationRequestId ""
                                                                                                                                  :IntegerValue ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"

	payload := strings.NewReader("{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 56

{
  "QualificationRequestId": "",
  "IntegerValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\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  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationRequestId: '',
  IntegerValue: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationRequestId: '', IntegerValue: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationRequestId":"","IntegerValue":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationRequestId": "",\n  "IntegerValue": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationRequestId: '', IntegerValue: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationRequestId: '', IntegerValue: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest');

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

req.type('json');
req.send({
  QualificationRequestId: '',
  IntegerValue: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationRequestId: '', IntegerValue: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationRequestId":"","IntegerValue":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationRequestId": @"",
                              @"IntegerValue": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest",
  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([
    'QualificationRequestId' => '',
    'IntegerValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest', [
  'body' => '{
  "QualificationRequestId": "",
  "IntegerValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'QualificationRequestId' => '',
  'IntegerValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationRequestId": "",
  "IntegerValue": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationRequestId": "",
  "IntegerValue": ""
}'

import http.client

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

payload = "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"

payload = {
    "QualificationRequestId": "",
    "IntegerValue": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest"

payload <- "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationRequestId\": \"\",\n  \"IntegerValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest";

    let payload = json!({
        "QualificationRequestId": "",
        "IntegerValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationRequestId": "",
  "IntegerValue": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationRequestId": "",\n  "IntegerValue": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationRequestId": "",
  "IntegerValue": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AcceptQualificationRequest")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:AssignmentId ""
                                                                                                                         :RequesterFeedback ""
                                                                                                                         :OverrideRejection ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"

	payload := strings.NewReader("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\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  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssignmentId: '',
  RequesterFeedback: '',
  OverrideRejection: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', RequesterFeedback: '', OverrideRejection: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","RequesterFeedback":"","OverrideRejection":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentId": "",\n  "RequesterFeedback": "",\n  "OverrideRejection": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({AssignmentId: '', RequesterFeedback: '', OverrideRejection: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssignmentId: '', RequesterFeedback: '', OverrideRejection: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment');

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

req.type('json');
req.send({
  AssignmentId: '',
  RequesterFeedback: '',
  OverrideRejection: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', RequesterFeedback: '', OverrideRejection: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","RequesterFeedback":"","OverrideRejection":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentId": @"",
                              @"RequesterFeedback": @"",
                              @"OverrideRejection": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment",
  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([
    'AssignmentId' => '',
    'RequesterFeedback' => '',
    'OverrideRejection' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment', [
  'body' => '{
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssignmentId' => '',
  'RequesterFeedback' => '',
  'OverrideRejection' => ''
]));

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

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

append(json_encode([
  'AssignmentId' => '',
  'RequesterFeedback' => '',
  'OverrideRejection' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
}'

import http.client

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

payload = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"

payload = {
    "AssignmentId": "",
    "RequesterFeedback": "",
    "OverrideRejection": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment"

payload <- "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\",\n  \"OverrideRejection\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment";

    let payload = json!({
        "AssignmentId": "",
        "RequesterFeedback": "",
        "OverrideRejection": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentId": "",\n  "RequesterFeedback": "",\n  "OverrideRejection": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AssignmentId": "",
  "RequesterFeedback": "",
  "OverrideRejection": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ApproveAssignment")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:QualificationTypeId ""
                                                                                                                                        :WorkerId ""
                                                                                                                                        :IntegerValue ""
                                                                                                                                        :SendNotification ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 97

{
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  WorkerId: '',
  IntegerValue: '',
  SendNotification: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', WorkerId: '', IntegerValue: '', SendNotification: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","WorkerId":"","IntegerValue":"","SendNotification":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "WorkerId": "",\n  "IntegerValue": "",\n  "SendNotification": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: '', WorkerId: '', IntegerValue: '', SendNotification: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: '', WorkerId: '', IntegerValue: '', SendNotification: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker');

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

req.type('json');
req.send({
  QualificationTypeId: '',
  WorkerId: '',
  IntegerValue: '',
  SendNotification: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', WorkerId: '', IntegerValue: '', SendNotification: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","WorkerId":"","IntegerValue":"","SendNotification":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"WorkerId": @"",
                              @"IntegerValue": @"",
                              @"SendNotification": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker",
  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([
    'QualificationTypeId' => '',
    'WorkerId' => '',
    'IntegerValue' => '',
    'SendNotification' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker', [
  'body' => '{
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationTypeId' => '',
  'WorkerId' => '',
  'IntegerValue' => '',
  'SendNotification' => ''
]));

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

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

append(json_encode([
  'QualificationTypeId' => '',
  'WorkerId' => '',
  'IntegerValue' => '',
  'SendNotification' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
}'

import http.client

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

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"

payload = {
    "QualificationTypeId": "",
    "WorkerId": "",
    "IntegerValue": "",
    "SendNotification": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\",\n  \"IntegerValue\": \"\",\n  \"SendNotification\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker";

    let payload = json!({
        "QualificationTypeId": "",
        "WorkerId": "",
        "IntegerValue": "",
        "SendNotification": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "WorkerId": "",\n  "IntegerValue": "",\n  "SendNotification": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "WorkerId": "",
  "IntegerValue": "",
  "SendNotification": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.AssociateQualificationWithWorker")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT" {:headers {:x-amz-target ""}
                                                                                                                           :content-type :json
                                                                                                                           :form-params {:HITId ""
                                                                                                                                         :NumberOfAdditionalAssignments ""
                                                                                                                                         :UniqueRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 84

{
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\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  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  NumberOfAdditionalAssignments: '',
  UniqueRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', NumberOfAdditionalAssignments: '', UniqueRequestToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","NumberOfAdditionalAssignments":"","UniqueRequestToken":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "NumberOfAdditionalAssignments": "",\n  "UniqueRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', NumberOfAdditionalAssignments: '', UniqueRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', NumberOfAdditionalAssignments: '', UniqueRequestToken: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT');

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

req.type('json');
req.send({
  HITId: '',
  NumberOfAdditionalAssignments: '',
  UniqueRequestToken: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', NumberOfAdditionalAssignments: '', UniqueRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","NumberOfAdditionalAssignments":"","UniqueRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"NumberOfAdditionalAssignments": @"",
                              @"UniqueRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT",
  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([
    'HITId' => '',
    'NumberOfAdditionalAssignments' => '',
    'UniqueRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT', [
  'body' => '{
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'NumberOfAdditionalAssignments' => '',
  'UniqueRequestToken' => ''
]));

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

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

append(json_encode([
  'HITId' => '',
  'NumberOfAdditionalAssignments' => '',
  'UniqueRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
}'

import http.client

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

payload = "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"

payload = {
    "HITId": "",
    "NumberOfAdditionalAssignments": "",
    "UniqueRequestToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT"

payload <- "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"NumberOfAdditionalAssignments\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT";

    let payload = json!({
        "HITId": "",
        "NumberOfAdditionalAssignments": "",
        "UniqueRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "NumberOfAdditionalAssignments": "",\n  "UniqueRequestToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "NumberOfAdditionalAssignments": "",
  "UniqueRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:MaxAssignments ""
                                                                                                                 :AutoApprovalDelayInSeconds ""
                                                                                                                 :LifetimeInSeconds ""
                                                                                                                 :AssignmentDurationInSeconds ""
                                                                                                                 :Reward ""
                                                                                                                 :Title ""
                                                                                                                 :Keywords ""
                                                                                                                 :Description ""
                                                                                                                 :Question ""
                                                                                                                 :RequesterAnnotation ""
                                                                                                                 :QualificationRequirements ""
                                                                                                                 :UniqueRequestToken ""
                                                                                                                 :AssignmentReviewPolicy ""
                                                                                                                 :HITReviewPolicy ""
                                                                                                                 :HITLayoutId ""
                                                                                                                 :HITLayoutParameters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"

	payload := strings.NewReader("{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 413

{
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxAssignments: '',
  AutoApprovalDelayInSeconds: '',
  LifetimeInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  Question: '',
  RequesterAnnotation: '',
  QualificationRequirements: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    MaxAssignments: '',
    AutoApprovalDelayInSeconds: '',
    LifetimeInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    Question: '',
    RequesterAnnotation: '',
    QualificationRequirements: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxAssignments":"","AutoApprovalDelayInSeconds":"","LifetimeInSeconds":"","AssignmentDurationInSeconds":"","Reward":"","Title":"","Keywords":"","Description":"","Question":"","RequesterAnnotation":"","QualificationRequirements":"","UniqueRequestToken":"","AssignmentReviewPolicy":"","HITReviewPolicy":"","HITLayoutId":"","HITLayoutParameters":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxAssignments": "",\n  "AutoApprovalDelayInSeconds": "",\n  "LifetimeInSeconds": "",\n  "AssignmentDurationInSeconds": "",\n  "Reward": "",\n  "Title": "",\n  "Keywords": "",\n  "Description": "",\n  "Question": "",\n  "RequesterAnnotation": "",\n  "QualificationRequirements": "",\n  "UniqueRequestToken": "",\n  "AssignmentReviewPolicy": "",\n  "HITReviewPolicy": "",\n  "HITLayoutId": "",\n  "HITLayoutParameters": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  MaxAssignments: '',
  AutoApprovalDelayInSeconds: '',
  LifetimeInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  Question: '',
  RequesterAnnotation: '',
  QualificationRequirements: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    MaxAssignments: '',
    AutoApprovalDelayInSeconds: '',
    LifetimeInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    Question: '',
    RequesterAnnotation: '',
    QualificationRequirements: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT');

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

req.type('json');
req.send({
  MaxAssignments: '',
  AutoApprovalDelayInSeconds: '',
  LifetimeInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  Question: '',
  RequesterAnnotation: '',
  QualificationRequirements: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    MaxAssignments: '',
    AutoApprovalDelayInSeconds: '',
    LifetimeInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    Question: '',
    RequesterAnnotation: '',
    QualificationRequirements: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxAssignments":"","AutoApprovalDelayInSeconds":"","LifetimeInSeconds":"","AssignmentDurationInSeconds":"","Reward":"","Title":"","Keywords":"","Description":"","Question":"","RequesterAnnotation":"","QualificationRequirements":"","UniqueRequestToken":"","AssignmentReviewPolicy":"","HITReviewPolicy":"","HITLayoutId":"","HITLayoutParameters":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"MaxAssignments": @"",
                              @"AutoApprovalDelayInSeconds": @"",
                              @"LifetimeInSeconds": @"",
                              @"AssignmentDurationInSeconds": @"",
                              @"Reward": @"",
                              @"Title": @"",
                              @"Keywords": @"",
                              @"Description": @"",
                              @"Question": @"",
                              @"RequesterAnnotation": @"",
                              @"QualificationRequirements": @"",
                              @"UniqueRequestToken": @"",
                              @"AssignmentReviewPolicy": @"",
                              @"HITReviewPolicy": @"",
                              @"HITLayoutId": @"",
                              @"HITLayoutParameters": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT",
  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([
    'MaxAssignments' => '',
    'AutoApprovalDelayInSeconds' => '',
    'LifetimeInSeconds' => '',
    'AssignmentDurationInSeconds' => '',
    'Reward' => '',
    'Title' => '',
    'Keywords' => '',
    'Description' => '',
    'Question' => '',
    'RequesterAnnotation' => '',
    'QualificationRequirements' => '',
    'UniqueRequestToken' => '',
    'AssignmentReviewPolicy' => '',
    'HITReviewPolicy' => '',
    'HITLayoutId' => '',
    'HITLayoutParameters' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT', [
  'body' => '{
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxAssignments' => '',
  'AutoApprovalDelayInSeconds' => '',
  'LifetimeInSeconds' => '',
  'AssignmentDurationInSeconds' => '',
  'Reward' => '',
  'Title' => '',
  'Keywords' => '',
  'Description' => '',
  'Question' => '',
  'RequesterAnnotation' => '',
  'QualificationRequirements' => '',
  'UniqueRequestToken' => '',
  'AssignmentReviewPolicy' => '',
  'HITReviewPolicy' => '',
  'HITLayoutId' => '',
  'HITLayoutParameters' => ''
]));

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

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

append(json_encode([
  'MaxAssignments' => '',
  'AutoApprovalDelayInSeconds' => '',
  'LifetimeInSeconds' => '',
  'AssignmentDurationInSeconds' => '',
  'Reward' => '',
  'Title' => '',
  'Keywords' => '',
  'Description' => '',
  'Question' => '',
  'RequesterAnnotation' => '',
  'QualificationRequirements' => '',
  'UniqueRequestToken' => '',
  'AssignmentReviewPolicy' => '',
  'HITReviewPolicy' => '',
  'HITLayoutId' => '',
  'HITLayoutParameters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}'

import http.client

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

payload = "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"

payload = {
    "MaxAssignments": "",
    "AutoApprovalDelayInSeconds": "",
    "LifetimeInSeconds": "",
    "AssignmentDurationInSeconds": "",
    "Reward": "",
    "Title": "",
    "Keywords": "",
    "Description": "",
    "Question": "",
    "RequesterAnnotation": "",
    "QualificationRequirements": "",
    "UniqueRequestToken": "",
    "AssignmentReviewPolicy": "",
    "HITReviewPolicy": "",
    "HITLayoutId": "",
    "HITLayoutParameters": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT"

payload <- "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"MaxAssignments\": \"\",\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"QualificationRequirements\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT";

    let payload = json!({
        "MaxAssignments": "",
        "AutoApprovalDelayInSeconds": "",
        "LifetimeInSeconds": "",
        "AssignmentDurationInSeconds": "",
        "Reward": "",
        "Title": "",
        "Keywords": "",
        "Description": "",
        "Question": "",
        "RequesterAnnotation": "",
        "QualificationRequirements": "",
        "UniqueRequestToken": "",
        "AssignmentReviewPolicy": "",
        "HITReviewPolicy": "",
        "HITLayoutId": "",
        "HITLayoutParameters": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxAssignments": "",\n  "AutoApprovalDelayInSeconds": "",\n  "LifetimeInSeconds": "",\n  "AssignmentDurationInSeconds": "",\n  "Reward": "",\n  "Title": "",\n  "Keywords": "",\n  "Description": "",\n  "Question": "",\n  "RequesterAnnotation": "",\n  "QualificationRequirements": "",\n  "UniqueRequestToken": "",\n  "AssignmentReviewPolicy": "",\n  "HITReviewPolicy": "",\n  "HITLayoutId": "",\n  "HITLayoutParameters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MaxAssignments": "",
  "AutoApprovalDelayInSeconds": "",
  "LifetimeInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "Question": "",
  "RequesterAnnotation": "",
  "QualificationRequirements": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AutoApprovalDelayInSeconds ""
                                                                                                                     :AssignmentDurationInSeconds ""
                                                                                                                     :Reward ""
                                                                                                                     :Title ""
                                                                                                                     :Keywords ""
                                                                                                                     :Description ""
                                                                                                                     :QualificationRequirements ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"

	payload := strings.NewReader("{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 180

{
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\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  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AutoApprovalDelayInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  QualificationRequirements: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoApprovalDelayInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    QualificationRequirements: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoApprovalDelayInSeconds":"","AssignmentDurationInSeconds":"","Reward":"","Title":"","Keywords":"","Description":"","QualificationRequirements":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutoApprovalDelayInSeconds": "",\n  "AssignmentDurationInSeconds": "",\n  "Reward": "",\n  "Title": "",\n  "Keywords": "",\n  "Description": "",\n  "QualificationRequirements": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  AutoApprovalDelayInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  QualificationRequirements: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AutoApprovalDelayInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    QualificationRequirements: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType');

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

req.type('json');
req.send({
  AutoApprovalDelayInSeconds: '',
  AssignmentDurationInSeconds: '',
  Reward: '',
  Title: '',
  Keywords: '',
  Description: '',
  QualificationRequirements: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutoApprovalDelayInSeconds: '',
    AssignmentDurationInSeconds: '',
    Reward: '',
    Title: '',
    Keywords: '',
    Description: '',
    QualificationRequirements: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutoApprovalDelayInSeconds":"","AssignmentDurationInSeconds":"","Reward":"","Title":"","Keywords":"","Description":"","QualificationRequirements":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AutoApprovalDelayInSeconds": @"",
                              @"AssignmentDurationInSeconds": @"",
                              @"Reward": @"",
                              @"Title": @"",
                              @"Keywords": @"",
                              @"Description": @"",
                              @"QualificationRequirements": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType",
  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([
    'AutoApprovalDelayInSeconds' => '',
    'AssignmentDurationInSeconds' => '',
    'Reward' => '',
    'Title' => '',
    'Keywords' => '',
    'Description' => '',
    'QualificationRequirements' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType', [
  'body' => '{
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutoApprovalDelayInSeconds' => '',
  'AssignmentDurationInSeconds' => '',
  'Reward' => '',
  'Title' => '',
  'Keywords' => '',
  'Description' => '',
  'QualificationRequirements' => ''
]));

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

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

append(json_encode([
  'AutoApprovalDelayInSeconds' => '',
  'AssignmentDurationInSeconds' => '',
  'Reward' => '',
  'Title' => '',
  'Keywords' => '',
  'Description' => '',
  'QualificationRequirements' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
}'

import http.client

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

payload = "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"

payload = {
    "AutoApprovalDelayInSeconds": "",
    "AssignmentDurationInSeconds": "",
    "Reward": "",
    "Title": "",
    "Keywords": "",
    "Description": "",
    "QualificationRequirements": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType"

payload <- "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AutoApprovalDelayInSeconds\": \"\",\n  \"AssignmentDurationInSeconds\": \"\",\n  \"Reward\": \"\",\n  \"Title\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationRequirements\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType";

    let payload = json!({
        "AutoApprovalDelayInSeconds": "",
        "AssignmentDurationInSeconds": "",
        "Reward": "",
        "Title": "",
        "Keywords": "",
        "Description": "",
        "QualificationRequirements": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutoApprovalDelayInSeconds": "",\n  "AssignmentDurationInSeconds": "",\n  "Reward": "",\n  "Title": "",\n  "Keywords": "",\n  "Description": "",\n  "QualificationRequirements": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AutoApprovalDelayInSeconds": "",
  "AssignmentDurationInSeconds": "",
  "Reward": "",
  "Title": "",
  "Keywords": "",
  "Description": "",
  "QualificationRequirements": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:HITTypeId ""
                                                                                                                            :MaxAssignments ""
                                                                                                                            :LifetimeInSeconds ""
                                                                                                                            :Question ""
                                                                                                                            :RequesterAnnotation ""
                                                                                                                            :UniqueRequestToken ""
                                                                                                                            :AssignmentReviewPolicy ""
                                                                                                                            :HITReviewPolicy ""
                                                                                                                            :HITLayoutId ""
                                                                                                                            :HITLayoutParameters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"

	payload := strings.NewReader("{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 254

{
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITTypeId: '',
  MaxAssignments: '',
  LifetimeInSeconds: '',
  Question: '',
  RequesterAnnotation: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HITTypeId: '',
    MaxAssignments: '',
    LifetimeInSeconds: '',
    Question: '',
    RequesterAnnotation: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","MaxAssignments":"","LifetimeInSeconds":"","Question":"","RequesterAnnotation":"","UniqueRequestToken":"","AssignmentReviewPolicy":"","HITReviewPolicy":"","HITLayoutId":"","HITLayoutParameters":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITTypeId": "",\n  "MaxAssignments": "",\n  "LifetimeInSeconds": "",\n  "Question": "",\n  "RequesterAnnotation": "",\n  "UniqueRequestToken": "",\n  "AssignmentReviewPolicy": "",\n  "HITReviewPolicy": "",\n  "HITLayoutId": "",\n  "HITLayoutParameters": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  HITTypeId: '',
  MaxAssignments: '',
  LifetimeInSeconds: '',
  Question: '',
  RequesterAnnotation: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    HITTypeId: '',
    MaxAssignments: '',
    LifetimeInSeconds: '',
    Question: '',
    RequesterAnnotation: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType');

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

req.type('json');
req.send({
  HITTypeId: '',
  MaxAssignments: '',
  LifetimeInSeconds: '',
  Question: '',
  RequesterAnnotation: '',
  UniqueRequestToken: '',
  AssignmentReviewPolicy: '',
  HITReviewPolicy: '',
  HITLayoutId: '',
  HITLayoutParameters: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HITTypeId: '',
    MaxAssignments: '',
    LifetimeInSeconds: '',
    Question: '',
    RequesterAnnotation: '',
    UniqueRequestToken: '',
    AssignmentReviewPolicy: '',
    HITReviewPolicy: '',
    HITLayoutId: '',
    HITLayoutParameters: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","MaxAssignments":"","LifetimeInSeconds":"","Question":"","RequesterAnnotation":"","UniqueRequestToken":"","AssignmentReviewPolicy":"","HITReviewPolicy":"","HITLayoutId":"","HITLayoutParameters":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITTypeId": @"",
                              @"MaxAssignments": @"",
                              @"LifetimeInSeconds": @"",
                              @"Question": @"",
                              @"RequesterAnnotation": @"",
                              @"UniqueRequestToken": @"",
                              @"AssignmentReviewPolicy": @"",
                              @"HITReviewPolicy": @"",
                              @"HITLayoutId": @"",
                              @"HITLayoutParameters": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType",
  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([
    'HITTypeId' => '',
    'MaxAssignments' => '',
    'LifetimeInSeconds' => '',
    'Question' => '',
    'RequesterAnnotation' => '',
    'UniqueRequestToken' => '',
    'AssignmentReviewPolicy' => '',
    'HITReviewPolicy' => '',
    'HITLayoutId' => '',
    'HITLayoutParameters' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType', [
  'body' => '{
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITTypeId' => '',
  'MaxAssignments' => '',
  'LifetimeInSeconds' => '',
  'Question' => '',
  'RequesterAnnotation' => '',
  'UniqueRequestToken' => '',
  'AssignmentReviewPolicy' => '',
  'HITReviewPolicy' => '',
  'HITLayoutId' => '',
  'HITLayoutParameters' => ''
]));

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

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

append(json_encode([
  'HITTypeId' => '',
  'MaxAssignments' => '',
  'LifetimeInSeconds' => '',
  'Question' => '',
  'RequesterAnnotation' => '',
  'UniqueRequestToken' => '',
  'AssignmentReviewPolicy' => '',
  'HITReviewPolicy' => '',
  'HITLayoutId' => '',
  'HITLayoutParameters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}'

import http.client

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

payload = "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"

payload = {
    "HITTypeId": "",
    "MaxAssignments": "",
    "LifetimeInSeconds": "",
    "Question": "",
    "RequesterAnnotation": "",
    "UniqueRequestToken": "",
    "AssignmentReviewPolicy": "",
    "HITReviewPolicy": "",
    "HITLayoutId": "",
    "HITLayoutParameters": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType"

payload <- "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITTypeId\": \"\",\n  \"MaxAssignments\": \"\",\n  \"LifetimeInSeconds\": \"\",\n  \"Question\": \"\",\n  \"RequesterAnnotation\": \"\",\n  \"UniqueRequestToken\": \"\",\n  \"AssignmentReviewPolicy\": \"\",\n  \"HITReviewPolicy\": \"\",\n  \"HITLayoutId\": \"\",\n  \"HITLayoutParameters\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType";

    let payload = json!({
        "HITTypeId": "",
        "MaxAssignments": "",
        "LifetimeInSeconds": "",
        "Question": "",
        "RequesterAnnotation": "",
        "UniqueRequestToken": "",
        "AssignmentReviewPolicy": "",
        "HITReviewPolicy": "",
        "HITLayoutId": "",
        "HITLayoutParameters": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITTypeId": "",\n  "MaxAssignments": "",\n  "LifetimeInSeconds": "",\n  "Question": "",\n  "RequesterAnnotation": "",\n  "UniqueRequestToken": "",\n  "AssignmentReviewPolicy": "",\n  "HITReviewPolicy": "",\n  "HITLayoutId": "",\n  "HITLayoutParameters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITTypeId": "",
  "MaxAssignments": "",
  "LifetimeInSeconds": "",
  "Question": "",
  "RequesterAnnotation": "",
  "UniqueRequestToken": "",
  "AssignmentReviewPolicy": "",
  "HITReviewPolicy": "",
  "HITLayoutId": "",
  "HITLayoutParameters": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateHITWithHITType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
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  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:Name ""
                                                                                                                               :Keywords ""
                                                                                                                               :Description ""
                                                                                                                               :QualificationTypeStatus ""
                                                                                                                               :RetryDelayInSeconds ""
                                                                                                                               :Test ""
                                                                                                                               :AnswerKey ""
                                                                                                                               :TestDurationInSeconds ""
                                                                                                                               :AutoGranted ""
                                                                                                                               :AutoGrantedValue ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 228

{
  "Name": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Keywords: '',
  Description: '',
  QualificationTypeStatus: '',
  RetryDelayInSeconds: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Keywords: '',
    Description: '',
    QualificationTypeStatus: '',
    RetryDelayInSeconds: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Keywords":"","Description":"","QualificationTypeStatus":"","RetryDelayInSeconds":"","Test":"","AnswerKey":"","TestDurationInSeconds":"","AutoGranted":"","AutoGrantedValue":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Keywords": "",\n  "Description": "",\n  "QualificationTypeStatus": "",\n  "RetryDelayInSeconds": "",\n  "Test": "",\n  "AnswerKey": "",\n  "TestDurationInSeconds": "",\n  "AutoGranted": "",\n  "AutoGrantedValue": ""\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  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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: '',
  Keywords: '',
  Description: '',
  QualificationTypeStatus: '',
  RetryDelayInSeconds: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Keywords: '',
    Description: '',
    QualificationTypeStatus: '',
    RetryDelayInSeconds: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType');

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

req.type('json');
req.send({
  Name: '',
  Keywords: '',
  Description: '',
  QualificationTypeStatus: '',
  RetryDelayInSeconds: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Keywords: '',
    Description: '',
    QualificationTypeStatus: '',
    RetryDelayInSeconds: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Keywords":"","Description":"","QualificationTypeStatus":"","RetryDelayInSeconds":"","Test":"","AnswerKey":"","TestDurationInSeconds":"","AutoGranted":"","AutoGrantedValue":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Keywords": @"",
                              @"Description": @"",
                              @"QualificationTypeStatus": @"",
                              @"RetryDelayInSeconds": @"",
                              @"Test": @"",
                              @"AnswerKey": @"",
                              @"TestDurationInSeconds": @"",
                              @"AutoGranted": @"",
                              @"AutoGrantedValue": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType",
  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' => '',
    'Keywords' => '',
    'Description' => '',
    'QualificationTypeStatus' => '',
    'RetryDelayInSeconds' => '',
    'Test' => '',
    'AnswerKey' => '',
    'TestDurationInSeconds' => '',
    'AutoGranted' => '',
    'AutoGrantedValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType', [
  'body' => '{
  "Name": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Keywords' => '',
  'Description' => '',
  'QualificationTypeStatus' => '',
  'RetryDelayInSeconds' => '',
  'Test' => '',
  'AnswerKey' => '',
  'TestDurationInSeconds' => '',
  'AutoGranted' => '',
  'AutoGrantedValue' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Keywords' => '',
  'Description' => '',
  'QualificationTypeStatus' => '',
  'RetryDelayInSeconds' => '',
  'Test' => '',
  'AnswerKey' => '',
  'TestDurationInSeconds' => '',
  'AutoGranted' => '',
  'AutoGrantedValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"

payload = {
    "Name": "",
    "Keywords": "",
    "Description": "",
    "QualificationTypeStatus": "",
    "RetryDelayInSeconds": "",
    "Test": "",
    "AnswerKey": "",
    "TestDurationInSeconds": "",
    "AutoGranted": "",
    "AutoGrantedValue": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType"

payload <- "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Keywords\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType";

    let payload = json!({
        "Name": "",
        "Keywords": "",
        "Description": "",
        "QualificationTypeStatus": "",
        "RetryDelayInSeconds": "",
        "Test": "",
        "AnswerKey": "",
        "TestDurationInSeconds": "",
        "AutoGranted": "",
        "AutoGrantedValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Keywords": "",\n  "Description": "",\n  "QualificationTypeStatus": "",\n  "RetryDelayInSeconds": "",\n  "Test": "",\n  "AnswerKey": "",\n  "TestDurationInSeconds": "",\n  "AutoGranted": "",\n  "AutoGrantedValue": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Keywords": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "RetryDelayInSeconds": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateQualificationType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:WorkerId ""
                                                                                                                         :Reason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"

	payload := strings.NewReader("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "WorkerId": "",
  "Reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkerId\": \"\",\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  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkerId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', Reason: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkerId": "",\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  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({WorkerId: '', Reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WorkerId: '', 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock');

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

req.type('json');
req.send({
  WorkerId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', Reason: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","Reason":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WorkerId": @"",
                              @"Reason": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock",
  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([
    'WorkerId' => '',
    'Reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock', [
  'body' => '{
  "WorkerId": "",
  "Reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'WorkerId' => '',
  'Reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "Reason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "Reason": ""
}'

import http.client

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

payload = "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"

payload = {
    "WorkerId": "",
    "Reason": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock"

payload <- "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"WorkerId\": \"\",\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock";

    let payload = json!({
        "WorkerId": "",
        "Reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "WorkerId": "",
  "Reason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkerId": "",\n  "Reason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkerId": "",
  "Reason": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.CreateWorkerBlock")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:HITId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"

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

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "HITId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\"\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  \"HITId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT",
  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([
    'HITId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT', [
  'body' => '{
  "HITId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'HITId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"

payload = { "HITId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT"

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

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["HITId": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:QualificationTypeId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"

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

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "QualificationTypeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\"\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  \"QualificationTypeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType",
  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([
    'QualificationTypeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType', [
  'body' => '{
  "QualificationTypeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'QualificationTypeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"

payload = { "QualificationTypeId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType"

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

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["QualificationTypeId": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteQualificationType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:WorkerId ""
                                                                                                                         :Reason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"

	payload := strings.NewReader("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "WorkerId": "",
  "Reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkerId\": \"\",\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  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkerId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', Reason: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkerId": "",\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  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({WorkerId: '', Reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WorkerId: '', 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock');

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

req.type('json');
req.send({
  WorkerId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', Reason: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","Reason":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WorkerId": @"",
                              @"Reason": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock",
  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([
    'WorkerId' => '',
    'Reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock', [
  'body' => '{
  "WorkerId": "",
  "Reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'WorkerId' => '',
  'Reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "Reason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "Reason": ""
}'

import http.client

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

payload = "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"

payload = {
    "WorkerId": "",
    "Reason": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock"

payload <- "{\n  \"WorkerId\": \"\",\n  \"Reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"WorkerId\": \"\",\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WorkerId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock";

    let payload = json!({
        "WorkerId": "",
        "Reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "WorkerId": "",
  "Reason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkerId": "",\n  "Reason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkerId": "",
  "Reason": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DeleteWorkerBlock")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:WorkerId ""
                                                                                                                                           :QualificationTypeId ""
                                                                                                                                           :Reason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"

	payload := strings.NewReader("{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\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  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkerId: '',
  QualificationTypeId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', QualificationTypeId: '', Reason: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","QualificationTypeId":"","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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkerId": "",\n  "QualificationTypeId": "",\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  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({WorkerId: '', QualificationTypeId: '', Reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WorkerId: '', QualificationTypeId: '', 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker');

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

req.type('json');
req.send({
  WorkerId: '',
  QualificationTypeId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WorkerId: '', QualificationTypeId: '', Reason: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","QualificationTypeId":"","Reason":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WorkerId": @"",
                              @"QualificationTypeId": @"",
                              @"Reason": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker",
  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([
    'WorkerId' => '',
    'QualificationTypeId' => '',
    'Reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker', [
  'body' => '{
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkerId' => '',
  'QualificationTypeId' => '',
  'Reason' => ''
]));

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

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

append(json_encode([
  'WorkerId' => '',
  'QualificationTypeId' => '',
  'Reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
}'

import http.client

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

payload = "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"

payload = {
    "WorkerId": "",
    "QualificationTypeId": "",
    "Reason": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker"

payload <- "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\n  \"Reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WorkerId\": \"\",\n  \"QualificationTypeId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker";

    let payload = json!({
        "WorkerId": "",
        "QualificationTypeId": "",
        "Reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkerId": "",\n  "QualificationTypeId": "",\n  "Reason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkerId": "",
  "QualificationTypeId": "",
  "Reason": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"

	payload := strings.NewReader("{}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance",
  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([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

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

payload = "{}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"

payload = {}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance"

payload <- "{}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")

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

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

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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAccountBalance")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AssignmentId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssignmentId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"

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

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "AssignmentId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentId\": \"\"\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  \"AssignmentId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({AssignmentId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssignmentId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment",
  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([
    'AssignmentId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment', [
  'body' => '{
  "AssignmentId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'AssignmentId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"

payload = { "AssignmentId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment"

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

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssignmentId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "AssignmentId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["AssignmentId": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetAssignment")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AssignmentId ""
                                                                                                                        :QuestionIdentifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"

	payload := strings.NewReader("{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "AssignmentId": "",
  "QuestionIdentifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\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  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssignmentId: '',
  QuestionIdentifier: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', QuestionIdentifier: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","QuestionIdentifier":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentId": "",\n  "QuestionIdentifier": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({AssignmentId: '', QuestionIdentifier: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssignmentId: '', QuestionIdentifier: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL');

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

req.type('json');
req.send({
  AssignmentId: '',
  QuestionIdentifier: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', QuestionIdentifier: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","QuestionIdentifier":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentId": @"",
                              @"QuestionIdentifier": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL",
  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([
    'AssignmentId' => '',
    'QuestionIdentifier' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL', [
  'body' => '{
  "AssignmentId": "",
  "QuestionIdentifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'AssignmentId' => '',
  'QuestionIdentifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "QuestionIdentifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "QuestionIdentifier": ""
}'

import http.client

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

payload = "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"

payload = {
    "AssignmentId": "",
    "QuestionIdentifier": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL"

payload <- "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssignmentId\": \"\",\n  \"QuestionIdentifier\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL";

    let payload = json!({
        "AssignmentId": "",
        "QuestionIdentifier": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "AssignmentId": "",
  "QuestionIdentifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentId": "",\n  "QuestionIdentifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AssignmentId": "",
  "QuestionIdentifier": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetFileUploadURL")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:HITId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"

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

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "HITId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\"\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  \"HITId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT",
  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([
    'HITId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT', [
  'body' => '{
  "HITId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'HITId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"

payload = { "HITId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT"

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

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["HITId": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:QualificationTypeId ""
                                                                                                                             :WorkerId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "QualificationTypeId": "",
  "WorkerId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  WorkerId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', WorkerId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","WorkerId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "WorkerId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: '', WorkerId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: '', WorkerId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore');

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

req.type('json');
req.send({
  QualificationTypeId: '',
  WorkerId: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', WorkerId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","WorkerId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"WorkerId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore",
  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([
    'QualificationTypeId' => '',
    'WorkerId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore', [
  'body' => '{
  "QualificationTypeId": "",
  "WorkerId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'QualificationTypeId' => '',
  'WorkerId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "WorkerId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "WorkerId": ""
}'

import http.client

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

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"

payload = {
    "QualificationTypeId": "",
    "WorkerId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"WorkerId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore";

    let payload = json!({
        "QualificationTypeId": "",
        "WorkerId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "WorkerId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "WorkerId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "WorkerId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationScore")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:QualificationTypeId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"

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

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "QualificationTypeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\"\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  \"QualificationTypeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType');

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

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

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType",
  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([
    'QualificationTypeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType', [
  'body' => '{
  "QualificationTypeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'QualificationTypeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"

payload = { "QualificationTypeId": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType"

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

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["QualificationTypeId": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.GetQualificationType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:HITId ""
                                                                                                                             :NextToken ""
                                                                                                                             :MaxResults 0
                                                                                                                             :AssignmentStatuses ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 83

{
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\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  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  NextToken: '',
  MaxResults: 0,
  AssignmentStatuses: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', NextToken: '', MaxResults: 0, AssignmentStatuses: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","NextToken":"","MaxResults":0,"AssignmentStatuses":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "NextToken": "",\n  "MaxResults": 0,\n  "AssignmentStatuses": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', NextToken: '', MaxResults: 0, AssignmentStatuses: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', NextToken: '', MaxResults: 0, AssignmentStatuses: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT');

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

req.type('json');
req.send({
  HITId: '',
  NextToken: '',
  MaxResults: 0,
  AssignmentStatuses: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', NextToken: '', MaxResults: 0, AssignmentStatuses: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","NextToken":"","MaxResults":0,"AssignmentStatuses":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"NextToken": @"",
                              @"MaxResults": @0,
                              @"AssignmentStatuses": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT",
  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([
    'HITId' => '',
    'NextToken' => '',
    'MaxResults' => 0,
    'AssignmentStatuses' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT', [
  'body' => '{
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'NextToken' => '',
  'MaxResults' => 0,
  'AssignmentStatuses' => ''
]));

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

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

append(json_encode([
  'HITId' => '',
  'NextToken' => '',
  'MaxResults' => 0,
  'AssignmentStatuses' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
}'

import http.client

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

payload = "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"

payload = {
    "HITId": "",
    "NextToken": "",
    "MaxResults": 0,
    "AssignmentStatuses": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT"

payload <- "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0,\n  \"AssignmentStatuses\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT";

    let payload = json!({
        "HITId": "",
        "NextToken": "",
        "MaxResults": 0,
        "AssignmentStatuses": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "NextToken": "",\n  "MaxResults": 0,\n  "AssignmentStatuses": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "NextToken": "",
  "MaxResults": 0,
  "AssignmentStatuses": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListAssignmentsForHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:HITId ""
                                                                                                                         :AssignmentId ""
                                                                                                                         :NextToken ""
                                                                                                                         :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 77

{
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  AssignmentId: '',
  NextToken: '',
  MaxResults: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', AssignmentId: '', NextToken: '', MaxResults: 0}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","AssignmentId":"","NextToken":"","MaxResults":0}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "AssignmentId": "",\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', AssignmentId: '', NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', AssignmentId: '', NextToken: '', MaxResults: 0},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments');

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

req.type('json');
req.send({
  HITId: '',
  AssignmentId: '',
  NextToken: '',
  MaxResults: 0
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', AssignmentId: '', NextToken: '', MaxResults: 0}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","AssignmentId":"","NextToken":"","MaxResults":0}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"AssignmentId": @"",
                              @"NextToken": @"",
                              @"MaxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments",
  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([
    'HITId' => '',
    'AssignmentId' => '',
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments', [
  'body' => '{
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'AssignmentId' => '',
  'NextToken' => '',
  'MaxResults' => 0
]));

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

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

append(json_encode([
  'HITId' => '',
  'AssignmentId' => '',
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

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

payload = "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"

payload = {
    "HITId": "",
    "AssignmentId": "",
    "NextToken": "",
    "MaxResults": 0
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments"

payload <- "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"AssignmentId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments";

    let payload = json!({
        "HITId": "",
        "AssignmentId": "",
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "AssignmentId": "",\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "AssignmentId": "",
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListBonusPayments")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:NextToken ""
                                                                                                                :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: 0}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":0}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NextToken: '', MaxResults: 0},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs');

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: 0
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: 0}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":0}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs",
  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([
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs', [
  'body' => '{
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => 0
]));

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

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

append(json_encode([
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"

payload = {
    "NextToken": "",
    "MaxResults": 0
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs";

    let payload = json!({
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITs")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:QualificationTypeId ""
                                                                                                                                    :NextToken ""
                                                                                                                                    :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: '', NextToken: '', MaxResults: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType');

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

req.type('json');
req.send({
  QualificationTypeId: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', NextToken: '', MaxResults: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","NextToken":"","MaxResults":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType",
  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([
    'QualificationTypeId' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType', [
  'body' => '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationTypeId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'QualificationTypeId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"

payload = {
    "QualificationTypeId": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType";

    let payload = json!({
        "QualificationTypeId": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListHITsForQualificationType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:QualificationTypeId ""
                                                                                                                                 :NextToken ""
                                                                                                                                 :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: '', NextToken: '', MaxResults: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests');

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

req.type('json');
req.send({
  QualificationTypeId: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', NextToken: '', MaxResults: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","NextToken":"","MaxResults":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests",
  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([
    'QualificationTypeId' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests', [
  'body' => '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationTypeId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'QualificationTypeId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"

payload = {
    "QualificationTypeId": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests";

    let payload = json!({
        "QualificationTypeId": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationRequests")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:Query ""
                                                                                                                              :MustBeRequestable ""
                                                                                                                              :MustBeOwnedByCaller ""
                                                                                                                              :NextToken ""
                                                                                                                              :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"

	payload := strings.NewReader("{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Query: '',
  MustBeRequestable: '',
  MustBeOwnedByCaller: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Query: '',
    MustBeRequestable: '',
    MustBeOwnedByCaller: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Query":"","MustBeRequestable":"","MustBeOwnedByCaller":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Query": "",\n  "MustBeRequestable": "",\n  "MustBeOwnedByCaller": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  Query: '',
  MustBeRequestable: '',
  MustBeOwnedByCaller: '',
  NextToken: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Query: '',
    MustBeRequestable: '',
    MustBeOwnedByCaller: '',
    NextToken: '',
    MaxResults: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes');

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

req.type('json');
req.send({
  Query: '',
  MustBeRequestable: '',
  MustBeOwnedByCaller: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Query: '',
    MustBeRequestable: '',
    MustBeOwnedByCaller: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Query":"","MustBeRequestable":"","MustBeOwnedByCaller":"","NextToken":"","MaxResults":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Query": @"",
                              @"MustBeRequestable": @"",
                              @"MustBeOwnedByCaller": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes",
  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([
    'Query' => '',
    'MustBeRequestable' => '',
    'MustBeOwnedByCaller' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes', [
  'body' => '{
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Query' => '',
  'MustBeRequestable' => '',
  'MustBeOwnedByCaller' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'Query' => '',
  'MustBeRequestable' => '',
  'MustBeOwnedByCaller' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"

payload = {
    "Query": "",
    "MustBeRequestable": "",
    "MustBeOwnedByCaller": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes"

payload <- "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Query\": \"\",\n  \"MustBeRequestable\": \"\",\n  \"MustBeOwnedByCaller\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes";

    let payload = json!({
        "Query": "",
        "MustBeRequestable": "",
        "MustBeOwnedByCaller": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Query": "",\n  "MustBeRequestable": "",\n  "MustBeOwnedByCaller": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Query": "",
  "MustBeRequestable": "",
  "MustBeOwnedByCaller": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListQualificationTypes")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:HITId ""
                                                                                                                                     :PolicyLevels ""
                                                                                                                                     :RetrieveActions ""
                                                                                                                                     :RetrieveResults ""
                                                                                                                                     :NextToken ""
                                                                                                                                     :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 128

{
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  PolicyLevels: '',
  RetrieveActions: '',
  RetrieveResults: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HITId: '',
    PolicyLevels: '',
    RetrieveActions: '',
    RetrieveResults: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","PolicyLevels":"","RetrieveActions":"","RetrieveResults":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "PolicyLevels": "",\n  "RetrieveActions": "",\n  "RetrieveResults": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  HITId: '',
  PolicyLevels: '',
  RetrieveActions: '',
  RetrieveResults: '',
  NextToken: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    HITId: '',
    PolicyLevels: '',
    RetrieveActions: '',
    RetrieveResults: '',
    NextToken: '',
    MaxResults: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT');

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

req.type('json');
req.send({
  HITId: '',
  PolicyLevels: '',
  RetrieveActions: '',
  RetrieveResults: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    HITId: '',
    PolicyLevels: '',
    RetrieveActions: '',
    RetrieveResults: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","PolicyLevels":"","RetrieveActions":"","RetrieveResults":"","NextToken":"","MaxResults":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"PolicyLevels": @"",
                              @"RetrieveActions": @"",
                              @"RetrieveResults": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT",
  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([
    'HITId' => '',
    'PolicyLevels' => '',
    'RetrieveActions' => '',
    'RetrieveResults' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT', [
  'body' => '{
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'PolicyLevels' => '',
  'RetrieveActions' => '',
  'RetrieveResults' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'HITId' => '',
  'PolicyLevels' => '',
  'RetrieveActions' => '',
  'RetrieveResults' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"

payload = {
    "HITId": "",
    "PolicyLevels": "",
    "RetrieveActions": "",
    "RetrieveResults": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT"

payload <- "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"PolicyLevels\": \"\",\n  \"RetrieveActions\": \"\",\n  \"RetrieveResults\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT";

    let payload = json!({
        "HITId": "",
        "PolicyLevels": "",
        "RetrieveActions": "",
        "RetrieveResults": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "PolicyLevels": "",\n  "RetrieveActions": "",\n  "RetrieveResults": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "PolicyLevels": "",
  "RetrieveActions": "",
  "RetrieveResults": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:HITTypeId ""
                                                                                                                          :Status ""
                                                                                                                          :NextToken ""
                                                                                                                          :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"

	payload := strings.NewReader("{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITTypeId: '',
  Status: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITTypeId: '', Status: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","Status":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITTypeId": "",\n  "Status": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITTypeId: '', Status: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITTypeId: '', Status: '', NextToken: '', MaxResults: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  HITTypeId: '',
  Status: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITTypeId: '', Status: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","Status":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITTypeId": @"",
                              @"Status": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs",
  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([
    'HITTypeId' => '',
    'Status' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs', [
  'body' => '{
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITTypeId' => '',
  'Status' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'HITTypeId' => '',
  'Status' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"

payload = {
    "HITTypeId": "",
    "Status": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs"

payload <- "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs";

    let payload = json!({
        "HITTypeId": "",
        "Status": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITTypeId": "",\n  "Status": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListReviewableHITs")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:NextToken ""
                                                                                                                        :MaxResults 0}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "NextToken": "",
  "MaxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":0}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({NextToken: '', MaxResults: 0}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NextToken: '', MaxResults: 0},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NextToken: '',
  MaxResults: 0
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks",
  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([
    'NextToken' => '',
    'MaxResults' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks', [
  'body' => '{
  "NextToken": "",
  "MaxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NextToken' => '',
  'MaxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": 0
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"

payload = {
    "NextToken": "",
    "MaxResults": 0
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks";

    let payload = json!({
        "NextToken": "",
        "MaxResults": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "NextToken": "",
  "MaxResults": 0
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": 0\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkerBlocks")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:QualificationTypeId ""
                                                                                                                                        :Status ""
                                                                                                                                        :NextToken ""
                                                                                                                                        :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  Status: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', Status: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","Status":"","NextToken":"","MaxResults":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "Status": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationTypeId: '', Status: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationTypeId: '', Status: '', NextToken: '', MaxResults: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QualificationTypeId: '',
  Status: '',
  NextToken: '',
  MaxResults: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationTypeId: '', Status: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","Status":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"Status": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType",
  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([
    'QualificationTypeId' => '',
    'Status' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType', [
  'body' => '{
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationTypeId' => '',
  'Status' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QualificationTypeId' => '',
  'Status' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"

payload = {
    "QualificationTypeId": "",
    "Status": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"Status\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType";

    let payload = json!({
        "QualificationTypeId": "",
        "Status": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "Status": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "Status": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.ListWorkersWithQualificationType")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:Subject ""
                                                                                                                     :MessageText ""
                                                                                                                     :WorkerIds ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"

	payload := strings.NewReader("{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\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  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Subject: '',
  MessageText: '',
  WorkerIds: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Subject: '', MessageText: '', WorkerIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Subject":"","MessageText":"","WorkerIds":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Subject": "",\n  "MessageText": "",\n  "WorkerIds": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({Subject: '', MessageText: '', WorkerIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Subject: '', MessageText: '', WorkerIds: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Subject: '',
  MessageText: '',
  WorkerIds: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Subject: '', MessageText: '', WorkerIds: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Subject":"","MessageText":"","WorkerIds":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Subject": @"",
                              @"MessageText": @"",
                              @"WorkerIds": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers",
  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([
    'Subject' => '',
    'MessageText' => '',
    'WorkerIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers', [
  'body' => '{
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Subject' => '',
  'MessageText' => '',
  'WorkerIds' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Subject' => '',
  'MessageText' => '',
  'WorkerIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"

payload = {
    "Subject": "",
    "MessageText": "",
    "WorkerIds": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers"

payload <- "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Subject\": \"\",\n  \"MessageText\": \"\",\n  \"WorkerIds\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers";

    let payload = json!({
        "Subject": "",
        "MessageText": "",
        "WorkerIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Subject": "",\n  "MessageText": "",\n  "WorkerIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Subject": "",
  "MessageText": "",
  "WorkerIds": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.NotifyWorkers")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:AssignmentId ""
                                                                                                                        :RequesterFeedback ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"

	payload := strings.NewReader("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "AssignmentId": "",
  "RequesterFeedback": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\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  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssignmentId: '',
  RequesterFeedback: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', RequesterFeedback: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","RequesterFeedback":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssignmentId": "",\n  "RequesterFeedback": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({AssignmentId: '', RequesterFeedback: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssignmentId: '', RequesterFeedback: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AssignmentId: '',
  RequesterFeedback: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssignmentId: '', RequesterFeedback: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssignmentId":"","RequesterFeedback":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssignmentId": @"",
                              @"RequesterFeedback": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment",
  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([
    'AssignmentId' => '',
    'RequesterFeedback' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment', [
  'body' => '{
  "AssignmentId": "",
  "RequesterFeedback": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssignmentId' => '',
  'RequesterFeedback' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AssignmentId' => '',
  'RequesterFeedback' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "RequesterFeedback": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssignmentId": "",
  "RequesterFeedback": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"

payload = {
    "AssignmentId": "",
    "RequesterFeedback": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment"

payload <- "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssignmentId\": \"\",\n  \"RequesterFeedback\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment";

    let payload = json!({
        "AssignmentId": "",
        "RequesterFeedback": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "AssignmentId": "",
  "RequesterFeedback": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssignmentId": "",\n  "RequesterFeedback": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AssignmentId": "",
  "RequesterFeedback": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectAssignment")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:QualificationRequestId ""
                                                                                                                                  :Reason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationRequestId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationRequestId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"

	payload := strings.NewReader("{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "QualificationRequestId": "",
  "Reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationRequestId\": \"\",\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  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationRequestId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationRequestId: '', Reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationRequestId":"","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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationRequestId": "",\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  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({QualificationRequestId: '', Reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QualificationRequestId: '', 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QualificationRequestId: '',
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QualificationRequestId: '', Reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationRequestId":"","Reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationRequestId": @"",
                              @"Reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest",
  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([
    'QualificationRequestId' => '',
    'Reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest', [
  'body' => '{
  "QualificationRequestId": "",
  "Reason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationRequestId' => '',
  'Reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QualificationRequestId' => '',
  'Reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationRequestId": "",
  "Reason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationRequestId": "",
  "Reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"

payload = {
    "QualificationRequestId": "",
    "Reason": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest"

payload <- "{\n  \"QualificationRequestId\": \"\",\n  \"Reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationRequestId\": \"\",\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationRequestId\": \"\",\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest";

    let payload = json!({
        "QualificationRequestId": "",
        "Reason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationRequestId": "",
  "Reason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationRequestId": "",\n  "Reason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationRequestId": "",
  "Reason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.RejectQualificationRequest")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:WorkerId ""
                                                                                                                 :BonusAmount ""
                                                                                                                 :AssignmentId ""
                                                                                                                 :Reason ""
                                                                                                                 :UniqueRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"

	payload := strings.NewReader("{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\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  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WorkerId: '',
  BonusAmount: '',
  AssignmentId: '',
  Reason: '',
  UniqueRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkerId: '',
    BonusAmount: '',
    AssignmentId: '',
    Reason: '',
    UniqueRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","BonusAmount":"","AssignmentId":"","Reason":"","UniqueRequestToken":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WorkerId": "",\n  "BonusAmount": "",\n  "AssignmentId": "",\n  "Reason": "",\n  "UniqueRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  WorkerId: '',
  BonusAmount: '',
  AssignmentId: '',
  Reason: '',
  UniqueRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    WorkerId: '',
    BonusAmount: '',
    AssignmentId: '',
    Reason: '',
    UniqueRequestToken: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WorkerId: '',
  BonusAmount: '',
  AssignmentId: '',
  Reason: '',
  UniqueRequestToken: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WorkerId: '',
    BonusAmount: '',
    AssignmentId: '',
    Reason: '',
    UniqueRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WorkerId":"","BonusAmount":"","AssignmentId":"","Reason":"","UniqueRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WorkerId": @"",
                              @"BonusAmount": @"",
                              @"AssignmentId": @"",
                              @"Reason": @"",
                              @"UniqueRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus",
  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([
    'WorkerId' => '',
    'BonusAmount' => '',
    'AssignmentId' => '',
    'Reason' => '',
    'UniqueRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus', [
  'body' => '{
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WorkerId' => '',
  'BonusAmount' => '',
  'AssignmentId' => '',
  'Reason' => '',
  'UniqueRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WorkerId' => '',
  'BonusAmount' => '',
  'AssignmentId' => '',
  'Reason' => '',
  'UniqueRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"

payload = {
    "WorkerId": "",
    "BonusAmount": "",
    "AssignmentId": "",
    "Reason": "",
    "UniqueRequestToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus"

payload <- "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WorkerId\": \"\",\n  \"BonusAmount\": \"\",\n  \"AssignmentId\": \"\",\n  \"Reason\": \"\",\n  \"UniqueRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus";

    let payload = json!({
        "WorkerId": "",
        "BonusAmount": "",
        "AssignmentId": "",
        "Reason": "",
        "UniqueRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WorkerId": "",\n  "BonusAmount": "",\n  "AssignmentId": "",\n  "Reason": "",\n  "UniqueRequestToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WorkerId": "",
  "BonusAmount": "",
  "AssignmentId": "",
  "Reason": "",
  "UniqueRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendBonus")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:Notification ""
                                                                                                                                 :TestEventType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"

	payload := strings.NewReader("{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "Notification": "",
  "TestEventType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\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  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Notification: '',
  TestEventType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Notification: '', TestEventType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Notification":"","TestEventType":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Notification": "",\n  "TestEventType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({Notification: '', TestEventType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Notification: '', TestEventType: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Notification: '',
  TestEventType: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Notification: '', TestEventType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Notification":"","TestEventType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Notification": @"",
                              @"TestEventType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification",
  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([
    'Notification' => '',
    'TestEventType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification', [
  'body' => '{
  "Notification": "",
  "TestEventType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Notification' => '',
  'TestEventType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Notification' => '',
  'TestEventType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Notification": "",
  "TestEventType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Notification": "",
  "TestEventType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"

payload = {
    "Notification": "",
    "TestEventType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification"

payload <- "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Notification\": \"\",\n  \"TestEventType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification";

    let payload = json!({
        "Notification": "",
        "TestEventType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "Notification": "",
  "TestEventType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Notification": "",\n  "TestEventType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Notification": "",
  "TestEventType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.SendTestEventNotification")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:HITId ""
                                                                                                                              :ExpireAt ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 35

{
  "HITId": "",
  "ExpireAt": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\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  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  ExpireAt: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', ExpireAt: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","ExpireAt":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "ExpireAt": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', ExpireAt: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', ExpireAt: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  HITId: '',
  ExpireAt: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', ExpireAt: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","ExpireAt":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"ExpireAt": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT",
  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([
    'HITId' => '',
    'ExpireAt' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT', [
  'body' => '{
  "HITId": "",
  "ExpireAt": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'ExpireAt' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'HITId' => '',
  'ExpireAt' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "ExpireAt": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "ExpireAt": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"

payload = {
    "HITId": "",
    "ExpireAt": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT"

payload <- "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"ExpireAt\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT";

    let payload = json!({
        "HITId": "",
        "ExpireAt": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "ExpireAt": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "ExpireAt": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "ExpireAt": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateExpirationForHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:HITId ""
                                                                                                                             :Revert ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "HITId": "",
  "Revert": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\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  \"HITId\": \"\",\n  \"Revert\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  Revert: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', Revert: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","Revert":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "Revert": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', Revert: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', Revert: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  HITId: '',
  Revert: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', Revert: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","Revert":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"Revert": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus",
  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([
    'HITId' => '',
    'Revert' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus', [
  'body' => '{
  "HITId": "",
  "Revert": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'Revert' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'HITId' => '',
  'Revert' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "Revert": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "Revert": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"

payload = {
    "HITId": "",
    "Revert": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus"

payload <- "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"Revert\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus";

    let payload = json!({
        "HITId": "",
        "Revert": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "Revert": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "Revert": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "Revert": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITReviewStatus")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:HITId ""
                                                                                                                          :HITTypeId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"

	payload := strings.NewReader("{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "HITId": "",
  "HITTypeId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\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  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITId: '',
  HITTypeId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', HITTypeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","HITTypeId":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITId": "",\n  "HITTypeId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITId: '', HITTypeId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITId: '', HITTypeId: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  HITId: '',
  HITTypeId: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITId: '', HITTypeId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITId":"","HITTypeId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITId": @"",
                              @"HITTypeId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT",
  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([
    'HITId' => '',
    'HITTypeId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT', [
  'body' => '{
  "HITId": "",
  "HITTypeId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITId' => '',
  'HITTypeId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'HITId' => '',
  'HITTypeId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "HITTypeId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITId": "",
  "HITTypeId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"

payload = {
    "HITId": "",
    "HITTypeId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT"

payload <- "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITId\": \"\",\n  \"HITTypeId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT";

    let payload = json!({
        "HITId": "",
        "HITTypeId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITId": "",
  "HITTypeId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITId": "",\n  "HITTypeId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITId": "",
  "HITTypeId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:HITTypeId ""
                                                                                                                                  :Notification ""
                                                                                                                                  :Active ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"

	payload := strings.NewReader("{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\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  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  HITTypeId: '',
  Notification: '',
  Active: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITTypeId: '', Notification: '', Active: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","Notification":"","Active":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "HITTypeId": "",\n  "Notification": "",\n  "Active": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({HITTypeId: '', Notification: '', Active: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {HITTypeId: '', Notification: '', Active: ''},
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  HITTypeId: '',
  Notification: '',
  Active: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {HITTypeId: '', Notification: '', Active: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"HITTypeId":"","Notification":"","Active":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"HITTypeId": @"",
                              @"Notification": @"",
                              @"Active": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings",
  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([
    'HITTypeId' => '',
    'Notification' => '',
    'Active' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings', [
  'body' => '{
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'HITTypeId' => '',
  'Notification' => '',
  'Active' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'HITTypeId' => '',
  'Notification' => '',
  'Active' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"

payload = {
    "HITTypeId": "",
    "Notification": "",
    "Active": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings"

payload <- "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"HITTypeId\": \"\",\n  \"Notification\": \"\",\n  \"Active\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings";

    let payload = json!({
        "HITTypeId": "",
        "Notification": "",
        "Active": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "HITTypeId": "",\n  "Notification": "",\n  "Active": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "HITTypeId": "",
  "Notification": "",
  "Active": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateNotificationSettings")! 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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:QualificationTypeId ""
                                                                                                                               :Description ""
                                                                                                                               :QualificationTypeStatus ""
                                                                                                                               :Test ""
                                                                                                                               :AnswerKey ""
                                                                                                                               :TestDurationInSeconds ""
                                                                                                                               :RetryDelayInSeconds ""
                                                                                                                               :AutoGranted ""
                                                                                                                               :AutoGrantedValue ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"

	payload := strings.NewReader("{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 225

{
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QualificationTypeId: '',
  Description: '',
  QualificationTypeStatus: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  RetryDelayInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    QualificationTypeId: '',
    Description: '',
    QualificationTypeStatus: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    RetryDelayInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","Description":"","QualificationTypeStatus":"","Test":"","AnswerKey":"","TestDurationInSeconds":"","RetryDelayInSeconds":"","AutoGranted":"","AutoGrantedValue":""}'
};

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QualificationTypeId": "",\n  "Description": "",\n  "QualificationTypeStatus": "",\n  "Test": "",\n  "AnswerKey": "",\n  "TestDurationInSeconds": "",\n  "RetryDelayInSeconds": "",\n  "AutoGranted": "",\n  "AutoGrantedValue": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  QualificationTypeId: '',
  Description: '',
  QualificationTypeStatus: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  RetryDelayInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    QualificationTypeId: '',
    Description: '',
    QualificationTypeStatus: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    RetryDelayInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  },
  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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QualificationTypeId: '',
  Description: '',
  QualificationTypeStatus: '',
  Test: '',
  AnswerKey: '',
  TestDurationInSeconds: '',
  RetryDelayInSeconds: '',
  AutoGranted: '',
  AutoGrantedValue: ''
});

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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    QualificationTypeId: '',
    Description: '',
    QualificationTypeStatus: '',
    Test: '',
    AnswerKey: '',
    TestDurationInSeconds: '',
    RetryDelayInSeconds: '',
    AutoGranted: '',
    AutoGrantedValue: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QualificationTypeId":"","Description":"","QualificationTypeStatus":"","Test":"","AnswerKey":"","TestDurationInSeconds":"","RetryDelayInSeconds":"","AutoGranted":"","AutoGrantedValue":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"QualificationTypeId": @"",
                              @"Description": @"",
                              @"QualificationTypeStatus": @"",
                              @"Test": @"",
                              @"AnswerKey": @"",
                              @"TestDurationInSeconds": @"",
                              @"RetryDelayInSeconds": @"",
                              @"AutoGranted": @"",
                              @"AutoGrantedValue": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"]
                                                       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}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType",
  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([
    'QualificationTypeId' => '',
    'Description' => '',
    'QualificationTypeStatus' => '',
    'Test' => '',
    'AnswerKey' => '',
    'TestDurationInSeconds' => '',
    'RetryDelayInSeconds' => '',
    'AutoGranted' => '',
    'AutoGrantedValue' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType', [
  'body' => '{
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QualificationTypeId' => '',
  'Description' => '',
  'QualificationTypeStatus' => '',
  'Test' => '',
  'AnswerKey' => '',
  'TestDurationInSeconds' => '',
  'RetryDelayInSeconds' => '',
  'AutoGranted' => '',
  'AutoGrantedValue' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QualificationTypeId' => '',
  'Description' => '',
  'QualificationTypeStatus' => '',
  'Test' => '',
  'AnswerKey' => '',
  'TestDurationInSeconds' => '',
  'RetryDelayInSeconds' => '',
  'AutoGranted' => '',
  'AutoGrantedValue' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"

payload = {
    "QualificationTypeId": "",
    "Description": "",
    "QualificationTypeStatus": "",
    "Test": "",
    "AnswerKey": "",
    "TestDurationInSeconds": "",
    "RetryDelayInSeconds": "",
    "AutoGranted": "",
    "AutoGrantedValue": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType"

payload <- "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"QualificationTypeId\": \"\",\n  \"Description\": \"\",\n  \"QualificationTypeStatus\": \"\",\n  \"Test\": \"\",\n  \"AnswerKey\": \"\",\n  \"TestDurationInSeconds\": \"\",\n  \"RetryDelayInSeconds\": \"\",\n  \"AutoGranted\": \"\",\n  \"AutoGrantedValue\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType";

    let payload = json!({
        "QualificationTypeId": "",
        "Description": "",
        "QualificationTypeStatus": "",
        "Test": "",
        "AnswerKey": "",
        "TestDurationInSeconds": "",
        "RetryDelayInSeconds": "",
        "AutoGranted": "",
        "AutoGrantedValue": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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 '{
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QualificationTypeId": "",\n  "Description": "",\n  "QualificationTypeStatus": "",\n  "Test": "",\n  "AnswerKey": "",\n  "TestDurationInSeconds": "",\n  "RetryDelayInSeconds": "",\n  "AutoGranted": "",\n  "AutoGrantedValue": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QualificationTypeId": "",
  "Description": "",
  "QualificationTypeStatus": "",
  "Test": "",
  "AnswerKey": "",
  "TestDurationInSeconds": "",
  "RetryDelayInSeconds": "",
  "AutoGranted": "",
  "AutoGrantedValue": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=MTurkRequesterServiceV20170117.UpdateQualificationType")! 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()