CURL *hnd = curl_easy_init();

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:CatalogId ""
                                                                                                     :DatabaseName ""
                                                                                                     :TableName ""
                                                                                                     :PartitionInputList ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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: 90

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInputList": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition")
  .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=AWSGlue.BatchCreatePartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionInputList: ''
});

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=AWSGlue.BatchCreatePartition');
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=AWSGlue.BatchCreatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionInputList: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionInputList":""}'
};

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=AWSGlue.BatchCreatePartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionInputList": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition")
  .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({CatalogId: '', DatabaseName: '', TableName: '', PartitionInputList: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionInputList: ''
});

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=AWSGlue.BatchCreatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionInputList: ''}
};

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=AWSGlue.BatchCreatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionInputList":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionInputList": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionInputList' => ''
  ]),
  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=AWSGlue.BatchCreatePartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInputList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionInputList' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionInputList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition');
$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=AWSGlue.BatchCreatePartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInputList": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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=AWSGlue.BatchCreatePartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionInputList": ""
}
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=AWSGlue.BatchCreatePartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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=AWSGlue.BatchCreatePartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInputList\": \"\"\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=AWSGlue.BatchCreatePartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionInputList": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInputList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionInputList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchCreatePartition'

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:CatalogId ""
                                                                                                      :ConnectionNameList ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\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

{
  "CatalogId": "",
  "ConnectionNameList": ""
}

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

client.close();

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

const data = JSON.stringify({
  CatalogId: '',
  ConnectionNameList: ''
});

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=AWSGlue.BatchDeleteConnection');
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=AWSGlue.BatchDeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionNameList: ''}
};

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

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

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=AWSGlue.BatchDeleteConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "ConnectionNameList": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection")
  .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({CatalogId: '', ConnectionNameList: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  ConnectionNameList: ''
});

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=AWSGlue.BatchDeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionNameList: ''}
};

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=AWSGlue.BatchDeleteConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","ConnectionNameList":""}'
};

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 = @{ @"CatalogId": @"",
                              @"ConnectionNameList": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection",
  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([
    'CatalogId' => '',
    'ConnectionNameList' => ''
  ]),
  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=AWSGlue.BatchDeleteConnection', [
  'body' => '{
  "CatalogId": "",
  "ConnectionNameList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'CatalogId' => '',
  'ConnectionNameList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection');
$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=AWSGlue.BatchDeleteConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "ConnectionNameList": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\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=AWSGlue.BatchDeleteConnection"

payload = {
    "CatalogId": "",
    "ConnectionNameList": ""
}
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=AWSGlue.BatchDeleteConnection"

payload <- "{\n  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\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=AWSGlue.BatchDeleteConnection")

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  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\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  \"CatalogId\": \"\",\n  \"ConnectionNameList\": \"\"\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=AWSGlue.BatchDeleteConnection";

    let payload = json!({
        "CatalogId": "",
        "ConnectionNameList": ""
    });

    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 '{
  "CatalogId": "",
  "ConnectionNameList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteConnection' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:CatalogId ""
                                                                                                     :DatabaseName ""
                                                                                                     :TableName ""
                                                                                                     :PartitionsToDelete ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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: 90

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToDelete": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition")
  .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=AWSGlue.BatchDeletePartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionsToDelete: ''
});

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=AWSGlue.BatchDeletePartition');
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=AWSGlue.BatchDeletePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionsToDelete: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionsToDelete":""}'
};

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=AWSGlue.BatchDeletePartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionsToDelete": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition")
  .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({CatalogId: '', DatabaseName: '', TableName: '', PartitionsToDelete: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionsToDelete: ''
});

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=AWSGlue.BatchDeletePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionsToDelete: ''}
};

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=AWSGlue.BatchDeletePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionsToDelete":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionsToDelete": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionsToDelete' => ''
  ]),
  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=AWSGlue.BatchDeletePartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToDelete": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionsToDelete' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionsToDelete' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition');
$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=AWSGlue.BatchDeletePartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToDelete": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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=AWSGlue.BatchDeletePartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionsToDelete": ""
}
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=AWSGlue.BatchDeletePartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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=AWSGlue.BatchDeletePartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToDelete\": \"\"\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=AWSGlue.BatchDeletePartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionsToDelete": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToDelete": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionsToDelete": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeletePartition'

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:CatalogId ""
                                                                                                 :DatabaseName ""
                                                                                                 :TablesToDelete ""
                                                                                                 :TransactionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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: 90

{
  "CatalogId": "",
  "DatabaseName": "",
  "TablesToDelete": "",
  "TransactionId": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable")
  .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=AWSGlue.BatchDeleteTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TablesToDelete: '',
  TransactionId: ''
});

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=AWSGlue.BatchDeleteTable');
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=AWSGlue.BatchDeleteTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TablesToDelete: '', TransactionId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TablesToDelete":"","TransactionId":""}'
};

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=AWSGlue.BatchDeleteTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TablesToDelete": "",\n  "TransactionId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable")
  .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({CatalogId: '', DatabaseName: '', TablesToDelete: '', TransactionId: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TablesToDelete: '',
  TransactionId: ''
});

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=AWSGlue.BatchDeleteTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TablesToDelete: '', TransactionId: ''}
};

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=AWSGlue.BatchDeleteTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TablesToDelete":"","TransactionId":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TablesToDelete": @"",
                              @"TransactionId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TablesToDelete' => '',
    'TransactionId' => ''
  ]),
  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=AWSGlue.BatchDeleteTable', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TablesToDelete": "",
  "TransactionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TablesToDelete' => '',
  'TransactionId' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TablesToDelete' => '',
  'TransactionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable');
$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=AWSGlue.BatchDeleteTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TablesToDelete": "",
  "TransactionId": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.BatchDeleteTable"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TablesToDelete": "",
    "TransactionId": ""
}
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=AWSGlue.BatchDeleteTable"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.BatchDeleteTable")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TablesToDelete\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.BatchDeleteTable";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TablesToDelete": "",
        "TransactionId": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TablesToDelete": "",
  "TransactionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TablesToDelete": "",\n  "TransactionId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTable'

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:CatalogId ""
                                                                                                        :DatabaseName ""
                                                                                                        :TableName ""
                                                                                                        :VersionIds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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: 82

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "VersionIds": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion")
  .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=AWSGlue.BatchDeleteTableVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  VersionIds: ''
});

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=AWSGlue.BatchDeleteTableVersion');
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=AWSGlue.BatchDeleteTableVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', VersionIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","VersionIds":""}'
};

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=AWSGlue.BatchDeleteTableVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "VersionIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion")
  .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({CatalogId: '', DatabaseName: '', TableName: '', VersionIds: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  VersionIds: ''
});

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=AWSGlue.BatchDeleteTableVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', VersionIds: ''}
};

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=AWSGlue.BatchDeleteTableVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","VersionIds":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"VersionIds": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'VersionIds' => ''
  ]),
  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=AWSGlue.BatchDeleteTableVersion', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "VersionIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'VersionIds' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'VersionIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion');
$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=AWSGlue.BatchDeleteTableVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "VersionIds": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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=AWSGlue.BatchDeleteTableVersion"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "VersionIds": ""
}
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=AWSGlue.BatchDeleteTableVersion"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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=AWSGlue.BatchDeleteTableVersion")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"VersionIds\": \"\"\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=AWSGlue.BatchDeleteTableVersion";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "VersionIds": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "VersionIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "VersionIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchDeleteTableVersion'

import Foundation

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

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

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

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  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints" {:headers {:x-amz-target ""}
                                                                                     :content-type :json
                                                                                     :form-params {:Names ""
                                                                                                   :IncludeBlueprint ""
                                                                                                   :IncludeParameterSpec ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\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: 73

{
  "Names": "",
  "IncludeBlueprint": "",
  "IncludeParameterSpec": ""
}

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

client.close();

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

const data = JSON.stringify({
  Names: '',
  IncludeBlueprint: '',
  IncludeParameterSpec: ''
});

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=AWSGlue.BatchGetBlueprints');
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=AWSGlue.BatchGetBlueprints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', IncludeBlueprint: '', IncludeParameterSpec: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","IncludeBlueprint":"","IncludeParameterSpec":""}'
};

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=AWSGlue.BatchGetBlueprints',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "IncludeBlueprint": "",\n  "IncludeParameterSpec": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints")
  .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({Names: '', IncludeBlueprint: '', IncludeParameterSpec: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Names: '',
  IncludeBlueprint: '',
  IncludeParameterSpec: ''
});

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=AWSGlue.BatchGetBlueprints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', IncludeBlueprint: '', IncludeParameterSpec: ''}
};

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=AWSGlue.BatchGetBlueprints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","IncludeBlueprint":"","IncludeParameterSpec":""}'
};

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 = @{ @"Names": @"",
                              @"IncludeBlueprint": @"",
                              @"IncludeParameterSpec": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints",
  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([
    'Names' => '',
    'IncludeBlueprint' => '',
    'IncludeParameterSpec' => ''
  ]),
  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=AWSGlue.BatchGetBlueprints', [
  'body' => '{
  "Names": "",
  "IncludeBlueprint": "",
  "IncludeParameterSpec": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Names' => '',
  'IncludeBlueprint' => '',
  'IncludeParameterSpec' => ''
]));

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

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

append(json_encode([
  'Names' => '',
  'IncludeBlueprint' => '',
  'IncludeParameterSpec' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints');
$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=AWSGlue.BatchGetBlueprints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "IncludeBlueprint": "",
  "IncludeParameterSpec": ""
}'

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

import http.client

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

payload = "{\n  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\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=AWSGlue.BatchGetBlueprints"

payload = {
    "Names": "",
    "IncludeBlueprint": "",
    "IncludeParameterSpec": ""
}
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=AWSGlue.BatchGetBlueprints"

payload <- "{\n  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\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=AWSGlue.BatchGetBlueprints")

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  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\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  \"Names\": \"\",\n  \"IncludeBlueprint\": \"\",\n  \"IncludeParameterSpec\": \"\"\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=AWSGlue.BatchGetBlueprints";

    let payload = json!({
        "Names": "",
        "IncludeBlueprint": "",
        "IncludeParameterSpec": ""
    });

    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 '{
  "Names": "",
  "IncludeBlueprint": "",
  "IncludeParameterSpec": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": "",\n  "IncludeBlueprint": "",\n  "IncludeParameterSpec": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetBlueprints'

import Foundation

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

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

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

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  \"CrawlerNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCrawlers"

	payload := strings.NewReader("{\n  \"CrawlerNames\": \"\"\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

{
  "CrawlerNames": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetCrawlers');
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=AWSGlue.BatchGetCrawlers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CrawlerNames: ''}
};

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

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

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=AWSGlue.BatchGetCrawlers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CrawlerNames": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CrawlerNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCrawlers")
  .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({CrawlerNames: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetCrawlers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CrawlerNames: ''}
};

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=AWSGlue.BatchGetCrawlers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CrawlerNames":""}'
};

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 = @{ @"CrawlerNames": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCrawlers",
  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([
    'CrawlerNames' => ''
  ]),
  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=AWSGlue.BatchGetCrawlers', [
  'body' => '{
  "CrawlerNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'CrawlerNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCrawlers');
$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=AWSGlue.BatchGetCrawlers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CrawlerNames": ""
}'

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

import http.client

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

payload = "{\n  \"CrawlerNames\": \"\"\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=AWSGlue.BatchGetCrawlers"

payload = { "CrawlerNames": "" }
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=AWSGlue.BatchGetCrawlers"

payload <- "{\n  \"CrawlerNames\": \"\"\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=AWSGlue.BatchGetCrawlers")

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  \"CrawlerNames\": \"\"\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  \"CrawlerNames\": \"\"\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=AWSGlue.BatchGetCrawlers";

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

    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 '{
  "CrawlerNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCrawlers' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"Names\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCustomEntityTypes"

	payload := strings.NewReader("{\n  \"Names\": \"\"\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

{
  "Names": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetCustomEntityTypes');
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=AWSGlue.BatchGetCustomEntityTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: ''}
};

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

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

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=AWSGlue.BatchGetCustomEntityTypes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCustomEntityTypes")
  .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({Names: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetCustomEntityTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: ''}
};

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=AWSGlue.BatchGetCustomEntityTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":""}'
};

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 = @{ @"Names": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCustomEntityTypes",
  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([
    'Names' => ''
  ]),
  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=AWSGlue.BatchGetCustomEntityTypes', [
  'body' => '{
  "Names": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'Names' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCustomEntityTypes');
$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=AWSGlue.BatchGetCustomEntityTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": ""
}'

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

import http.client

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

payload = "{\n  \"Names\": \"\"\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=AWSGlue.BatchGetCustomEntityTypes"

payload = { "Names": "" }
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=AWSGlue.BatchGetCustomEntityTypes"

payload <- "{\n  \"Names\": \"\"\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=AWSGlue.BatchGetCustomEntityTypes")

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  \"Names\": \"\"\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  \"Names\": \"\"\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=AWSGlue.BatchGetCustomEntityTypes";

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

    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 '{
  "Names": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetCustomEntityTypes' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"ResultIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDataQualityResult"

	payload := strings.NewReader("{\n  \"ResultIds\": \"\"\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: 21

{
  "ResultIds": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetDataQualityResult');
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=AWSGlue.BatchGetDataQualityResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResultIds: ''}
};

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

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

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=AWSGlue.BatchGetDataQualityResult',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResultIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResultIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDataQualityResult")
  .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({ResultIds: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetDataQualityResult',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResultIds: ''}
};

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=AWSGlue.BatchGetDataQualityResult';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResultIds":""}'
};

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 = @{ @"ResultIds": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDataQualityResult",
  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([
    'ResultIds' => ''
  ]),
  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=AWSGlue.BatchGetDataQualityResult', [
  'body' => '{
  "ResultIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'ResultIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDataQualityResult');
$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=AWSGlue.BatchGetDataQualityResult' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResultIds": ""
}'

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

import http.client

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

payload = "{\n  \"ResultIds\": \"\"\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=AWSGlue.BatchGetDataQualityResult"

payload = { "ResultIds": "" }
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=AWSGlue.BatchGetDataQualityResult"

payload <- "{\n  \"ResultIds\": \"\"\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=AWSGlue.BatchGetDataQualityResult")

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  \"ResultIds\": \"\"\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  \"ResultIds\": \"\"\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=AWSGlue.BatchGetDataQualityResult";

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

    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 '{
  "ResultIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDataQualityResult' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"DevEndpointNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDevEndpoints"

	payload := strings.NewReader("{\n  \"DevEndpointNames\": \"\"\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: 28

{
  "DevEndpointNames": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetDevEndpoints');
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=AWSGlue.BatchGetDevEndpoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DevEndpointNames: ''}
};

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

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

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=AWSGlue.BatchGetDevEndpoints',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DevEndpointNames": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DevEndpointNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDevEndpoints")
  .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({DevEndpointNames: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetDevEndpoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DevEndpointNames: ''}
};

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=AWSGlue.BatchGetDevEndpoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DevEndpointNames":""}'
};

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 = @{ @"DevEndpointNames": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDevEndpoints",
  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([
    'DevEndpointNames' => ''
  ]),
  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=AWSGlue.BatchGetDevEndpoints', [
  'body' => '{
  "DevEndpointNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'DevEndpointNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDevEndpoints');
$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=AWSGlue.BatchGetDevEndpoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DevEndpointNames": ""
}'

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

import http.client

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

payload = "{\n  \"DevEndpointNames\": \"\"\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=AWSGlue.BatchGetDevEndpoints"

payload = { "DevEndpointNames": "" }
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=AWSGlue.BatchGetDevEndpoints"

payload <- "{\n  \"DevEndpointNames\": \"\"\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=AWSGlue.BatchGetDevEndpoints")

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  \"DevEndpointNames\": \"\"\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  \"DevEndpointNames\": \"\"\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=AWSGlue.BatchGetDevEndpoints";

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

    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 '{
  "DevEndpointNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetDevEndpoints' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"JobNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetJobs"

	payload := strings.NewReader("{\n  \"JobNames\": \"\"\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: 20

{
  "JobNames": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetJobs');
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=AWSGlue.BatchGetJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobNames: ''}
};

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

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

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=AWSGlue.BatchGetJobs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobNames": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"JobNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetJobs")
  .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({JobNames: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobNames: ''}
};

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=AWSGlue.BatchGetJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobNames":""}'
};

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 = @{ @"JobNames": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetJobs",
  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([
    'JobNames' => ''
  ]),
  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=AWSGlue.BatchGetJobs', [
  'body' => '{
  "JobNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'JobNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetJobs');
$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=AWSGlue.BatchGetJobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobNames": ""
}'

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

import http.client

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

payload = "{\n  \"JobNames\": \"\"\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=AWSGlue.BatchGetJobs"

payload = { "JobNames": "" }
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=AWSGlue.BatchGetJobs"

payload <- "{\n  \"JobNames\": \"\"\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=AWSGlue.BatchGetJobs")

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  \"JobNames\": \"\"\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  \"JobNames\": \"\"\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=AWSGlue.BatchGetJobs";

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

    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 '{
  "JobNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetJobs' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:CatalogId ""
                                                                                                  :DatabaseName ""
                                                                                                  :TableName ""
                                                                                                  :PartitionsToGet ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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: 87

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToGet": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition")
  .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=AWSGlue.BatchGetPartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionsToGet: ''
});

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=AWSGlue.BatchGetPartition');
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=AWSGlue.BatchGetPartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionsToGet: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionsToGet":""}'
};

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=AWSGlue.BatchGetPartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionsToGet": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition")
  .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({CatalogId: '', DatabaseName: '', TableName: '', PartitionsToGet: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionsToGet: ''
});

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=AWSGlue.BatchGetPartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionsToGet: ''}
};

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=AWSGlue.BatchGetPartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionsToGet":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionsToGet": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionsToGet' => ''
  ]),
  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=AWSGlue.BatchGetPartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToGet": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionsToGet' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionsToGet' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition');
$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=AWSGlue.BatchGetPartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToGet": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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=AWSGlue.BatchGetPartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionsToGet": ""
}
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=AWSGlue.BatchGetPartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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=AWSGlue.BatchGetPartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionsToGet\": \"\"\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=AWSGlue.BatchGetPartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionsToGet": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionsToGet": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionsToGet": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetPartition'

import Foundation

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

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

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

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  \"TriggerNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetTriggers"

	payload := strings.NewReader("{\n  \"TriggerNames\": \"\"\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

{
  "TriggerNames": ""
}

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

client.close();

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

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

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=AWSGlue.BatchGetTriggers');
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=AWSGlue.BatchGetTriggers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TriggerNames: ''}
};

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

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

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=AWSGlue.BatchGetTriggers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TriggerNames": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TriggerNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetTriggers")
  .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({TriggerNames: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.BatchGetTriggers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TriggerNames: ''}
};

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=AWSGlue.BatchGetTriggers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TriggerNames":""}'
};

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 = @{ @"TriggerNames": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetTriggers",
  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([
    'TriggerNames' => ''
  ]),
  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=AWSGlue.BatchGetTriggers', [
  'body' => '{
  "TriggerNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'TriggerNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetTriggers');
$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=AWSGlue.BatchGetTriggers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TriggerNames": ""
}'

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

import http.client

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

payload = "{\n  \"TriggerNames\": \"\"\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=AWSGlue.BatchGetTriggers"

payload = { "TriggerNames": "" }
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=AWSGlue.BatchGetTriggers"

payload <- "{\n  \"TriggerNames\": \"\"\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=AWSGlue.BatchGetTriggers")

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  \"TriggerNames\": \"\"\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  \"TriggerNames\": \"\"\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=AWSGlue.BatchGetTriggers";

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

    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 '{
  "TriggerNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetTriggers' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:Names ""
                                                                                                  :IncludeGraph ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows"

	payload := strings.NewReader("{\n  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\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: 39

{
  "Names": "",
  "IncludeGraph": ""
}

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

client.close();

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

const data = JSON.stringify({
  Names: '',
  IncludeGraph: ''
});

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=AWSGlue.BatchGetWorkflows');
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=AWSGlue.BatchGetWorkflows',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', IncludeGraph: ''}
};

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

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

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=AWSGlue.BatchGetWorkflows',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Names": "",\n  "IncludeGraph": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows")
  .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({Names: '', IncludeGraph: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Names: '',
  IncludeGraph: ''
});

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=AWSGlue.BatchGetWorkflows',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Names: '', IncludeGraph: ''}
};

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=AWSGlue.BatchGetWorkflows';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Names":"","IncludeGraph":""}'
};

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 = @{ @"Names": @"",
                              @"IncludeGraph": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows",
  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([
    'Names' => '',
    'IncludeGraph' => ''
  ]),
  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=AWSGlue.BatchGetWorkflows', [
  'body' => '{
  "Names": "",
  "IncludeGraph": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'Names' => '',
  'IncludeGraph' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows');
$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=AWSGlue.BatchGetWorkflows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": "",
  "IncludeGraph": ""
}'

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

import http.client

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

payload = "{\n  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\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=AWSGlue.BatchGetWorkflows"

payload = {
    "Names": "",
    "IncludeGraph": ""
}
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=AWSGlue.BatchGetWorkflows"

payload <- "{\n  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\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=AWSGlue.BatchGetWorkflows")

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  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\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  \"Names\": \"\",\n  \"IncludeGraph\": \"\"\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=AWSGlue.BatchGetWorkflows";

    let payload = json!({
        "Names": "",
        "IncludeGraph": ""
    });

    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 '{
  "Names": "",
  "IncludeGraph": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchGetWorkflows' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:JobName ""
                                                                                                :JobRunIds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun"

	payload := strings.NewReader("{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\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: 38

{
  "JobName": "",
  "JobRunIds": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun")
  .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=AWSGlue.BatchStopJobRun")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobName: '',
  JobRunIds: ''
});

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=AWSGlue.BatchStopJobRun');
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=AWSGlue.BatchStopJobRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: '', JobRunIds: ''}
};

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

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

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=AWSGlue.BatchStopJobRun',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobName": "",\n  "JobRunIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun")
  .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({JobName: '', JobRunIds: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  JobName: '',
  JobRunIds: ''
});

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=AWSGlue.BatchStopJobRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: '', JobRunIds: ''}
};

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=AWSGlue.BatchStopJobRun';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":"","JobRunIds":""}'
};

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 = @{ @"JobName": @"",
                              @"JobRunIds": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'JobName' => '',
    'JobRunIds' => ''
  ]),
  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=AWSGlue.BatchStopJobRun', [
  'body' => '{
  "JobName": "",
  "JobRunIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'JobName' => '',
  'JobRunIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun');
$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=AWSGlue.BatchStopJobRun' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": "",
  "JobRunIds": ""
}'

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

import http.client

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

payload = "{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\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=AWSGlue.BatchStopJobRun"

payload = {
    "JobName": "",
    "JobRunIds": ""
}
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=AWSGlue.BatchStopJobRun"

payload <- "{\n  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\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=AWSGlue.BatchStopJobRun")

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  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\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  \"JobName\": \"\",\n  \"JobRunIds\": \"\"\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=AWSGlue.BatchStopJobRun";

    let payload = json!({
        "JobName": "",
        "JobRunIds": ""
    });

    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 '{
  "JobName": "",
  "JobRunIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchStopJobRun' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:CatalogId ""
                                                                                                     :DatabaseName ""
                                                                                                     :TableName ""
                                                                                                     :Entries ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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: 79

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "Entries": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition")
  .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=AWSGlue.BatchUpdatePartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  Entries: ''
});

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=AWSGlue.BatchUpdatePartition');
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=AWSGlue.BatchUpdatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', Entries: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","Entries":""}'
};

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=AWSGlue.BatchUpdatePartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "Entries": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition")
  .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({CatalogId: '', DatabaseName: '', TableName: '', Entries: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  Entries: ''
});

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=AWSGlue.BatchUpdatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', Entries: ''}
};

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=AWSGlue.BatchUpdatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","Entries":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"Entries": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'Entries' => ''
  ]),
  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=AWSGlue.BatchUpdatePartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "Entries": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'Entries' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'Entries' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition');
$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=AWSGlue.BatchUpdatePartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "Entries": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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=AWSGlue.BatchUpdatePartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "Entries": ""
}
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=AWSGlue.BatchUpdatePartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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=AWSGlue.BatchUpdatePartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"Entries\": \"\"\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=AWSGlue.BatchUpdatePartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "Entries": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "Entries": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "Entries": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.BatchUpdatePartition'

import Foundation

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

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

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

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  \"RunId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRuleRecommendationRun"

	payload := strings.NewReader("{\n  \"RunId\": \"\"\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

{
  "RunId": ""
}

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

client.close();

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

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

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=AWSGlue.CancelDataQualityRuleRecommendationRun');
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=AWSGlue.CancelDataQualityRuleRecommendationRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RunId: ''}
};

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

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

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=AWSGlue.CancelDataQualityRuleRecommendationRun',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RunId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RunId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRuleRecommendationRun")
  .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({RunId: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.CancelDataQualityRuleRecommendationRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RunId: ''}
};

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=AWSGlue.CancelDataQualityRuleRecommendationRun';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RunId":""}'
};

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 = @{ @"RunId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRuleRecommendationRun",
  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([
    'RunId' => ''
  ]),
  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=AWSGlue.CancelDataQualityRuleRecommendationRun', [
  'body' => '{
  "RunId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'RunId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRuleRecommendationRun');
$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=AWSGlue.CancelDataQualityRuleRecommendationRun' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RunId": ""
}'

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

import http.client

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

payload = "{\n  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRuleRecommendationRun"

payload = { "RunId": "" }
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=AWSGlue.CancelDataQualityRuleRecommendationRun"

payload <- "{\n  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRuleRecommendationRun")

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  \"RunId\": \"\"\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  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRuleRecommendationRun";

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

    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 '{
  "RunId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRuleRecommendationRun' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"RunId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRulesetEvaluationRun"

	payload := strings.NewReader("{\n  \"RunId\": \"\"\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

{
  "RunId": ""
}

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

client.close();

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

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

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=AWSGlue.CancelDataQualityRulesetEvaluationRun');
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=AWSGlue.CancelDataQualityRulesetEvaluationRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RunId: ''}
};

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

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

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=AWSGlue.CancelDataQualityRulesetEvaluationRun',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RunId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RunId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRulesetEvaluationRun")
  .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({RunId: ''}));
req.end();

const request = require('request');

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

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

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

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=AWSGlue.CancelDataQualityRulesetEvaluationRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RunId: ''}
};

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=AWSGlue.CancelDataQualityRulesetEvaluationRun';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RunId":""}'
};

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 = @{ @"RunId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRulesetEvaluationRun",
  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([
    'RunId' => ''
  ]),
  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=AWSGlue.CancelDataQualityRulesetEvaluationRun', [
  'body' => '{
  "RunId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'RunId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRulesetEvaluationRun');
$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=AWSGlue.CancelDataQualityRulesetEvaluationRun' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RunId": ""
}'

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

import http.client

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

payload = "{\n  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRulesetEvaluationRun"

payload = { "RunId": "" }
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=AWSGlue.CancelDataQualityRulesetEvaluationRun"

payload <- "{\n  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRulesetEvaluationRun")

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  \"RunId\": \"\"\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  \"RunId\": \"\"\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=AWSGlue.CancelDataQualityRulesetEvaluationRun";

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

    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 '{
  "RunId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelDataQualityRulesetEvaluationRun' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:TransformId ""
                                                                                                :TaskRunId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun"

	payload := strings.NewReader("{\n  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\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: 42

{
  "TransformId": "",
  "TaskRunId": ""
}

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

client.close();

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

const data = JSON.stringify({
  TransformId: '',
  TaskRunId: ''
});

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=AWSGlue.CancelMLTaskRun');
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=AWSGlue.CancelMLTaskRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransformId: '', TaskRunId: ''}
};

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

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

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=AWSGlue.CancelMLTaskRun',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransformId": "",\n  "TaskRunId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun")
  .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({TransformId: '', TaskRunId: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  TransformId: '',
  TaskRunId: ''
});

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=AWSGlue.CancelMLTaskRun',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransformId: '', TaskRunId: ''}
};

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=AWSGlue.CancelMLTaskRun';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransformId":"","TaskRunId":""}'
};

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 = @{ @"TransformId": @"",
                              @"TaskRunId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun",
  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([
    'TransformId' => '',
    'TaskRunId' => ''
  ]),
  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=AWSGlue.CancelMLTaskRun', [
  'body' => '{
  "TransformId": "",
  "TaskRunId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'TransformId' => '',
  'TaskRunId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun');
$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=AWSGlue.CancelMLTaskRun' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransformId": "",
  "TaskRunId": ""
}'

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

import http.client

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

payload = "{\n  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\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=AWSGlue.CancelMLTaskRun"

payload = {
    "TransformId": "",
    "TaskRunId": ""
}
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=AWSGlue.CancelMLTaskRun"

payload <- "{\n  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\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=AWSGlue.CancelMLTaskRun")

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  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\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  \"TransformId\": \"\",\n  \"TaskRunId\": \"\"\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=AWSGlue.CancelMLTaskRun";

    let payload = json!({
        "TransformId": "",
        "TaskRunId": ""
    });

    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 '{
  "TransformId": "",
  "TaskRunId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelMLTaskRun' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:SessionId ""
                                                                                                :Id ""
                                                                                                :RequestOrigin ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement"

	payload := strings.NewReader("{\n  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\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

{
  "SessionId": "",
  "Id": "",
  "RequestOrigin": ""
}

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

client.close();

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

const data = JSON.stringify({
  SessionId: '',
  Id: '',
  RequestOrigin: ''
});

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=AWSGlue.CancelStatement');
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=AWSGlue.CancelStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SessionId: '', Id: '', RequestOrigin: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SessionId":"","Id":"","RequestOrigin":""}'
};

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=AWSGlue.CancelStatement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SessionId": "",\n  "Id": "",\n  "RequestOrigin": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement")
  .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({SessionId: '', Id: '', RequestOrigin: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  SessionId: '',
  Id: '',
  RequestOrigin: ''
});

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=AWSGlue.CancelStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SessionId: '', Id: '', RequestOrigin: ''}
};

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=AWSGlue.CancelStatement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SessionId":"","Id":"","RequestOrigin":""}'
};

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 = @{ @"SessionId": @"",
                              @"Id": @"",
                              @"RequestOrigin": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement",
  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([
    'SessionId' => '',
    'Id' => '',
    'RequestOrigin' => ''
  ]),
  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=AWSGlue.CancelStatement', [
  'body' => '{
  "SessionId": "",
  "Id": "",
  "RequestOrigin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SessionId' => '',
  'Id' => '',
  'RequestOrigin' => ''
]));

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

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

append(json_encode([
  'SessionId' => '',
  'Id' => '',
  'RequestOrigin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement');
$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=AWSGlue.CancelStatement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SessionId": "",
  "Id": "",
  "RequestOrigin": ""
}'

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

import http.client

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

payload = "{\n  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CancelStatement"

payload = {
    "SessionId": "",
    "Id": "",
    "RequestOrigin": ""
}
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=AWSGlue.CancelStatement"

payload <- "{\n  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CancelStatement")

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  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\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  \"SessionId\": \"\",\n  \"Id\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CancelStatement";

    let payload = json!({
        "SessionId": "",
        "Id": "",
        "RequestOrigin": ""
    });

    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 '{
  "SessionId": "",
  "Id": "",
  "RequestOrigin": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SessionId": "",\n  "Id": "",\n  "RequestOrigin": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CancelStatement'

import Foundation

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

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

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

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  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:DataFormat ""
                                                                                                           :SchemaDefinition ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity"

	payload := strings.NewReader("{\n  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\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: 48

{
  "DataFormat": "",
  "SchemaDefinition": ""
}

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

client.close();

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

const data = JSON.stringify({
  DataFormat: '',
  SchemaDefinition: ''
});

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=AWSGlue.CheckSchemaVersionValidity');
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=AWSGlue.CheckSchemaVersionValidity',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DataFormat: '', SchemaDefinition: ''}
};

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

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

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=AWSGlue.CheckSchemaVersionValidity',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DataFormat": "",\n  "SchemaDefinition": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity")
  .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({DataFormat: '', SchemaDefinition: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  DataFormat: '',
  SchemaDefinition: ''
});

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=AWSGlue.CheckSchemaVersionValidity',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DataFormat: '', SchemaDefinition: ''}
};

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=AWSGlue.CheckSchemaVersionValidity';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DataFormat":"","SchemaDefinition":""}'
};

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 = @{ @"DataFormat": @"",
                              @"SchemaDefinition": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity",
  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([
    'DataFormat' => '',
    'SchemaDefinition' => ''
  ]),
  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=AWSGlue.CheckSchemaVersionValidity', [
  'body' => '{
  "DataFormat": "",
  "SchemaDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'DataFormat' => '',
  'SchemaDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity');
$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=AWSGlue.CheckSchemaVersionValidity' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DataFormat": "",
  "SchemaDefinition": ""
}'

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

import http.client

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

payload = "{\n  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CheckSchemaVersionValidity"

payload = {
    "DataFormat": "",
    "SchemaDefinition": ""
}
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=AWSGlue.CheckSchemaVersionValidity"

payload <- "{\n  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CheckSchemaVersionValidity")

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  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\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  \"DataFormat\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CheckSchemaVersionValidity";

    let payload = json!({
        "DataFormat": "",
        "SchemaDefinition": ""
    });

    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 '{
  "DataFormat": "",
  "SchemaDefinition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CheckSchemaVersionValidity' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:Name ""
                                                                                                :Description ""
                                                                                                :BlueprintLocation ""
                                                                                                :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\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

{
  "Name": "",
  "Description": "",
  "BlueprintLocation": "",
  "Tags": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint")
  .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=AWSGlue.CreateBlueprint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  BlueprintLocation: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint');
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=AWSGlue.CreateBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Description: '', BlueprintLocation: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","BlueprintLocation":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "BlueprintLocation": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint")
  .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: '', Description: '', BlueprintLocation: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', Description: '', BlueprintLocation: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  BlueprintLocation: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Description: '', BlueprintLocation: '', Tags: ''}
};

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=AWSGlue.CreateBlueprint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","BlueprintLocation":"","Tags":""}'
};

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": @"",
                              @"Description": @"",
                              @"BlueprintLocation": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint"]
                                                       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=AWSGlue.CreateBlueprint" 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  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint",
  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' => '',
    'Description' => '',
    'BlueprintLocation' => '',
    'Tags' => ''
  ]),
  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=AWSGlue.CreateBlueprint', [
  'body' => '{
  "Name": "",
  "Description": "",
  "BlueprintLocation": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'BlueprintLocation' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'BlueprintLocation' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint');
$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=AWSGlue.CreateBlueprint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "BlueprintLocation": "",
  "Tags": ""
}'

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

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateBlueprint"

payload = {
    "Name": "",
    "Description": "",
    "BlueprintLocation": "",
    "Tags": ""
}
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=AWSGlue.CreateBlueprint"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateBlueprint")

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  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"BlueprintLocation\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "BlueprintLocation": "",
        "Tags": ""
    });

    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": "",
  "Description": "",
  "BlueprintLocation": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint' \
  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  "Description": "",\n  "BlueprintLocation": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateBlueprint'

import Foundation

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

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

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

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  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:GrokClassifier ""
                                                                                                 :XMLClassifier ""
                                                                                                 :JsonClassifier ""
                                                                                                 :CsvClassifier ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier"

	payload := strings.NewReader("{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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: 96

{
  "GrokClassifier": "",
  "XMLClassifier": "",
  "JsonClassifier": "",
  "CsvClassifier": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier")
  .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=AWSGlue.CreateClassifier")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GrokClassifier: '',
  XMLClassifier: '',
  JsonClassifier: '',
  CsvClassifier: ''
});

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=AWSGlue.CreateClassifier');
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=AWSGlue.CreateClassifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GrokClassifier: '', XMLClassifier: '', JsonClassifier: '', CsvClassifier: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GrokClassifier":"","XMLClassifier":"","JsonClassifier":"","CsvClassifier":""}'
};

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=AWSGlue.CreateClassifier',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GrokClassifier": "",\n  "XMLClassifier": "",\n  "JsonClassifier": "",\n  "CsvClassifier": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier")
  .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({GrokClassifier: '', XMLClassifier: '', JsonClassifier: '', CsvClassifier: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  GrokClassifier: '',
  XMLClassifier: '',
  JsonClassifier: '',
  CsvClassifier: ''
});

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=AWSGlue.CreateClassifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GrokClassifier: '', XMLClassifier: '', JsonClassifier: '', CsvClassifier: ''}
};

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=AWSGlue.CreateClassifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GrokClassifier":"","XMLClassifier":"","JsonClassifier":"","CsvClassifier":""}'
};

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 = @{ @"GrokClassifier": @"",
                              @"XMLClassifier": @"",
                              @"JsonClassifier": @"",
                              @"CsvClassifier": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier",
  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([
    'GrokClassifier' => '',
    'XMLClassifier' => '',
    'JsonClassifier' => '',
    'CsvClassifier' => ''
  ]),
  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=AWSGlue.CreateClassifier', [
  'body' => '{
  "GrokClassifier": "",
  "XMLClassifier": "",
  "JsonClassifier": "",
  "CsvClassifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GrokClassifier' => '',
  'XMLClassifier' => '',
  'JsonClassifier' => '',
  'CsvClassifier' => ''
]));

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

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

append(json_encode([
  'GrokClassifier' => '',
  'XMLClassifier' => '',
  'JsonClassifier' => '',
  'CsvClassifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier');
$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=AWSGlue.CreateClassifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GrokClassifier": "",
  "XMLClassifier": "",
  "JsonClassifier": "",
  "CsvClassifier": ""
}'

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

import http.client

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

payload = "{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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=AWSGlue.CreateClassifier"

payload = {
    "GrokClassifier": "",
    "XMLClassifier": "",
    "JsonClassifier": "",
    "CsvClassifier": ""
}
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=AWSGlue.CreateClassifier"

payload <- "{\n  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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=AWSGlue.CreateClassifier")

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  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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  \"GrokClassifier\": \"\",\n  \"XMLClassifier\": \"\",\n  \"JsonClassifier\": \"\",\n  \"CsvClassifier\": \"\"\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=AWSGlue.CreateClassifier";

    let payload = json!({
        "GrokClassifier": "",
        "XMLClassifier": "",
        "JsonClassifier": "",
        "CsvClassifier": ""
    });

    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 '{
  "GrokClassifier": "",
  "XMLClassifier": "",
  "JsonClassifier": "",
  "CsvClassifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GrokClassifier": "",\n  "XMLClassifier": "",\n  "JsonClassifier": "",\n  "CsvClassifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateClassifier'

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:CatalogId ""
                                                                                                 :ConnectionInput ""
                                                                                                 :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\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: 60

{
  "CatalogId": "",
  "ConnectionInput": "",
  "Tags": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection")
  .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=AWSGlue.CreateConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  ConnectionInput: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection');
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=AWSGlue.CreateConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionInput: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","ConnectionInput":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "ConnectionInput": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection")
  .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({CatalogId: '', ConnectionInput: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', ConnectionInput: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection');

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

req.type('json');
req.send({
  CatalogId: '',
  ConnectionInput: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionInput: '', Tags: ''}
};

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=AWSGlue.CreateConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","ConnectionInput":"","Tags":""}'
};

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 = @{ @"CatalogId": @"",
                              @"ConnectionInput": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection",
  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([
    'CatalogId' => '',
    'ConnectionInput' => '',
    'Tags' => ''
  ]),
  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=AWSGlue.CreateConnection', [
  'body' => '{
  "CatalogId": "",
  "ConnectionInput": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'ConnectionInput' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'ConnectionInput' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection');
$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=AWSGlue.CreateConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "ConnectionInput": "",
  "Tags": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateConnection"

payload = {
    "CatalogId": "",
    "ConnectionInput": "",
    "Tags": ""
}
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=AWSGlue.CreateConnection"

payload <- "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateConnection")

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  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"CatalogId\": \"\",\n  \"ConnectionInput\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CatalogId": "",
        "ConnectionInput": "",
        "Tags": ""
    });

    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 '{
  "CatalogId": "",
  "ConnectionInput": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "ConnectionInput": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateConnection'

import Foundation

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

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

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

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  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:Name ""
                                                                                              :Role ""
                                                                                              :DatabaseName ""
                                                                                              :Description ""
                                                                                              :Targets ""
                                                                                              :Schedule ""
                                                                                              :Classifiers ""
                                                                                              :TablePrefix ""
                                                                                              :SchemaChangePolicy ""
                                                                                              :RecrawlPolicy ""
                                                                                              :LineageConfiguration ""
                                                                                              :LakeFormationConfiguration ""
                                                                                              :Configuration ""
                                                                                              :CrawlerSecurityConfiguration ""
                                                                                              :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\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: 342

{
  "Name": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler")
  .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=AWSGlue.CreateCrawler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Role: '',
  DatabaseName: '',
  Description: '',
  Targets: '',
  Schedule: '',
  Classifiers: '',
  TablePrefix: '',
  SchemaChangePolicy: '',
  RecrawlPolicy: '',
  LineageConfiguration: '',
  LakeFormationConfiguration: '',
  Configuration: '',
  CrawlerSecurityConfiguration: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler');
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=AWSGlue.CreateCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Role: '',
    DatabaseName: '',
    Description: '',
    Targets: '',
    Schedule: '',
    Classifiers: '',
    TablePrefix: '',
    SchemaChangePolicy: '',
    RecrawlPolicy: '',
    LineageConfiguration: '',
    LakeFormationConfiguration: '',
    Configuration: '',
    CrawlerSecurityConfiguration: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Role":"","DatabaseName":"","Description":"","Targets":"","Schedule":"","Classifiers":"","TablePrefix":"","SchemaChangePolicy":"","RecrawlPolicy":"","LineageConfiguration":"","LakeFormationConfiguration":"","Configuration":"","CrawlerSecurityConfiguration":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Role": "",\n  "DatabaseName": "",\n  "Description": "",\n  "Targets": "",\n  "Schedule": "",\n  "Classifiers": "",\n  "TablePrefix": "",\n  "SchemaChangePolicy": "",\n  "RecrawlPolicy": "",\n  "LineageConfiguration": "",\n  "LakeFormationConfiguration": "",\n  "Configuration": "",\n  "CrawlerSecurityConfiguration": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler")
  .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: '',
  Role: '',
  DatabaseName: '',
  Description: '',
  Targets: '',
  Schedule: '',
  Classifiers: '',
  TablePrefix: '',
  SchemaChangePolicy: '',
  RecrawlPolicy: '',
  LineageConfiguration: '',
  LakeFormationConfiguration: '',
  Configuration: '',
  CrawlerSecurityConfiguration: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Role: '',
    DatabaseName: '',
    Description: '',
    Targets: '',
    Schedule: '',
    Classifiers: '',
    TablePrefix: '',
    SchemaChangePolicy: '',
    RecrawlPolicy: '',
    LineageConfiguration: '',
    LakeFormationConfiguration: '',
    Configuration: '',
    CrawlerSecurityConfiguration: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler');

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

req.type('json');
req.send({
  Name: '',
  Role: '',
  DatabaseName: '',
  Description: '',
  Targets: '',
  Schedule: '',
  Classifiers: '',
  TablePrefix: '',
  SchemaChangePolicy: '',
  RecrawlPolicy: '',
  LineageConfiguration: '',
  LakeFormationConfiguration: '',
  Configuration: '',
  CrawlerSecurityConfiguration: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Role: '',
    DatabaseName: '',
    Description: '',
    Targets: '',
    Schedule: '',
    Classifiers: '',
    TablePrefix: '',
    SchemaChangePolicy: '',
    RecrawlPolicy: '',
    LineageConfiguration: '',
    LakeFormationConfiguration: '',
    Configuration: '',
    CrawlerSecurityConfiguration: '',
    Tags: ''
  }
};

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=AWSGlue.CreateCrawler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Role":"","DatabaseName":"","Description":"","Targets":"","Schedule":"","Classifiers":"","TablePrefix":"","SchemaChangePolicy":"","RecrawlPolicy":"","LineageConfiguration":"","LakeFormationConfiguration":"","Configuration":"","CrawlerSecurityConfiguration":"","Tags":""}'
};

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": @"",
                              @"Role": @"",
                              @"DatabaseName": @"",
                              @"Description": @"",
                              @"Targets": @"",
                              @"Schedule": @"",
                              @"Classifiers": @"",
                              @"TablePrefix": @"",
                              @"SchemaChangePolicy": @"",
                              @"RecrawlPolicy": @"",
                              @"LineageConfiguration": @"",
                              @"LakeFormationConfiguration": @"",
                              @"Configuration": @"",
                              @"CrawlerSecurityConfiguration": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler"]
                                                       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=AWSGlue.CreateCrawler" 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  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler",
  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' => '',
    'Role' => '',
    'DatabaseName' => '',
    'Description' => '',
    'Targets' => '',
    'Schedule' => '',
    'Classifiers' => '',
    'TablePrefix' => '',
    'SchemaChangePolicy' => '',
    'RecrawlPolicy' => '',
    'LineageConfiguration' => '',
    'LakeFormationConfiguration' => '',
    'Configuration' => '',
    'CrawlerSecurityConfiguration' => '',
    'Tags' => ''
  ]),
  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=AWSGlue.CreateCrawler', [
  'body' => '{
  "Name": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Role' => '',
  'DatabaseName' => '',
  'Description' => '',
  'Targets' => '',
  'Schedule' => '',
  'Classifiers' => '',
  'TablePrefix' => '',
  'SchemaChangePolicy' => '',
  'RecrawlPolicy' => '',
  'LineageConfiguration' => '',
  'LakeFormationConfiguration' => '',
  'Configuration' => '',
  'CrawlerSecurityConfiguration' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Role' => '',
  'DatabaseName' => '',
  'Description' => '',
  'Targets' => '',
  'Schedule' => '',
  'Classifiers' => '',
  'TablePrefix' => '',
  'SchemaChangePolicy' => '',
  'RecrawlPolicy' => '',
  'LineageConfiguration' => '',
  'LakeFormationConfiguration' => '',
  'Configuration' => '',
  'CrawlerSecurityConfiguration' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler');
$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=AWSGlue.CreateCrawler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateCrawler"

payload = {
    "Name": "",
    "Role": "",
    "DatabaseName": "",
    "Description": "",
    "Targets": "",
    "Schedule": "",
    "Classifiers": "",
    "TablePrefix": "",
    "SchemaChangePolicy": "",
    "RecrawlPolicy": "",
    "LineageConfiguration": "",
    "LakeFormationConfiguration": "",
    "Configuration": "",
    "CrawlerSecurityConfiguration": "",
    "Tags": ""
}
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=AWSGlue.CreateCrawler"

payload <- "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateCrawler")

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  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Role\": \"\",\n  \"DatabaseName\": \"\",\n  \"Description\": \"\",\n  \"Targets\": \"\",\n  \"Schedule\": \"\",\n  \"Classifiers\": \"\",\n  \"TablePrefix\": \"\",\n  \"SchemaChangePolicy\": \"\",\n  \"RecrawlPolicy\": \"\",\n  \"LineageConfiguration\": \"\",\n  \"LakeFormationConfiguration\": \"\",\n  \"Configuration\": \"\",\n  \"CrawlerSecurityConfiguration\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Role": "",
        "DatabaseName": "",
        "Description": "",
        "Targets": "",
        "Schedule": "",
        "Classifiers": "",
        "TablePrefix": "",
        "SchemaChangePolicy": "",
        "RecrawlPolicy": "",
        "LineageConfiguration": "",
        "LakeFormationConfiguration": "",
        "Configuration": "",
        "CrawlerSecurityConfiguration": "",
        "Tags": ""
    });

    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": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler' \
  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  "Role": "",\n  "DatabaseName": "",\n  "Description": "",\n  "Targets": "",\n  "Schedule": "",\n  "Classifiers": "",\n  "TablePrefix": "",\n  "SchemaChangePolicy": "",\n  "RecrawlPolicy": "",\n  "LineageConfiguration": "",\n  "LakeFormationConfiguration": "",\n  "Configuration": "",\n  "CrawlerSecurityConfiguration": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCrawler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Role": "",
  "DatabaseName": "",
  "Description": "",
  "Targets": "",
  "Schedule": "",
  "Classifiers": "",
  "TablePrefix": "",
  "SchemaChangePolicy": "",
  "RecrawlPolicy": "",
  "LineageConfiguration": "",
  "LakeFormationConfiguration": "",
  "Configuration": "",
  "CrawlerSecurityConfiguration": "",
  "Tags": ""
] as [String : Any]

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

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

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  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:Name ""
                                                                                                       :RegexString ""
                                                                                                       :ContextWords ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\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

{
  "Name": "",
  "RegexString": "",
  "ContextWords": ""
}

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

client.close();

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

const data = JSON.stringify({
  Name: '',
  RegexString: '',
  ContextWords: ''
});

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=AWSGlue.CreateCustomEntityType');
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=AWSGlue.CreateCustomEntityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', RegexString: '', ContextWords: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","RegexString":"","ContextWords":""}'
};

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=AWSGlue.CreateCustomEntityType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "RegexString": "",\n  "ContextWords": ""\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  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType")
  .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: '', RegexString: '', ContextWords: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Name: '',
  RegexString: '',
  ContextWords: ''
});

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=AWSGlue.CreateCustomEntityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', RegexString: '', ContextWords: ''}
};

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=AWSGlue.CreateCustomEntityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","RegexString":"","ContextWords":""}'
};

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": @"",
                              @"RegexString": @"",
                              @"ContextWords": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType"]
                                                       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=AWSGlue.CreateCustomEntityType" 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  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType",
  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' => '',
    'RegexString' => '',
    'ContextWords' => ''
  ]),
  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=AWSGlue.CreateCustomEntityType', [
  'body' => '{
  "Name": "",
  "RegexString": "",
  "ContextWords": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'RegexString' => '',
  'ContextWords' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'RegexString' => '',
  'ContextWords' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType');
$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=AWSGlue.CreateCustomEntityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "RegexString": "",
  "ContextWords": ""
}'

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

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\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=AWSGlue.CreateCustomEntityType"

payload = {
    "Name": "",
    "RegexString": "",
    "ContextWords": ""
}
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=AWSGlue.CreateCustomEntityType"

payload <- "{\n  \"Name\": \"\",\n  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\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=AWSGlue.CreateCustomEntityType")

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  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\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  \"RegexString\": \"\",\n  \"ContextWords\": \"\"\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=AWSGlue.CreateCustomEntityType";

    let payload = json!({
        "Name": "",
        "RegexString": "",
        "ContextWords": ""
    });

    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": "",
  "RegexString": "",
  "ContextWords": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType' \
  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  "RegexString": "",\n  "ContextWords": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateCustomEntityType'

import Foundation

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

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

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

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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:Name ""
                                                                                                         :Description ""
                                                                                                         :Ruleset ""
                                                                                                         :Tags ""
                                                                                                         :TargetTable ""
                                                                                                         :ClientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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: 110

{
  "Name": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset")
  .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=AWSGlue.CreateDataQualityRuleset")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  Ruleset: '',
  Tags: '',
  TargetTable: '',
  ClientToken: ''
});

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=AWSGlue.CreateDataQualityRuleset');
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=AWSGlue.CreateDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    Ruleset: '',
    Tags: '',
    TargetTable: '',
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Ruleset":"","Tags":"","TargetTable":"","ClientToken":""}'
};

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=AWSGlue.CreateDataQualityRuleset',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "Ruleset": "",\n  "Tags": "",\n  "TargetTable": "",\n  "ClientToken": ""\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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset")
  .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: '',
  Description: '',
  Ruleset: '',
  Tags: '',
  TargetTable: '',
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    Ruleset: '',
    Tags: '',
    TargetTable: '',
    ClientToken: ''
  },
  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=AWSGlue.CreateDataQualityRuleset');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  Ruleset: '',
  Tags: '',
  TargetTable: '',
  ClientToken: ''
});

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=AWSGlue.CreateDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    Ruleset: '',
    Tags: '',
    TargetTable: '',
    ClientToken: ''
  }
};

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=AWSGlue.CreateDataQualityRuleset';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Ruleset":"","Tags":"","TargetTable":"","ClientToken":""}'
};

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": @"",
                              @"Description": @"",
                              @"Ruleset": @"",
                              @"Tags": @"",
                              @"TargetTable": @"",
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset"]
                                                       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=AWSGlue.CreateDataQualityRuleset" 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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset",
  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' => '',
    'Description' => '',
    'Ruleset' => '',
    'Tags' => '',
    'TargetTable' => '',
    'ClientToken' => ''
  ]),
  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=AWSGlue.CreateDataQualityRuleset', [
  'body' => '{
  "Name": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'Ruleset' => '',
  'Tags' => '',
  'TargetTable' => '',
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'Ruleset' => '',
  'Tags' => '',
  'TargetTable' => '',
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset');
$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=AWSGlue.CreateDataQualityRuleset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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=AWSGlue.CreateDataQualityRuleset"

payload = {
    "Name": "",
    "Description": "",
    "Ruleset": "",
    "Tags": "",
    "TargetTable": "",
    "ClientToken": ""
}
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=AWSGlue.CreateDataQualityRuleset"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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=AWSGlue.CreateDataQualityRuleset")

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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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  \"Description\": \"\",\n  \"Ruleset\": \"\",\n  \"Tags\": \"\",\n  \"TargetTable\": \"\",\n  \"ClientToken\": \"\"\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=AWSGlue.CreateDataQualityRuleset";

    let payload = json!({
        "Name": "",
        "Description": "",
        "Ruleset": "",
        "Tags": "",
        "TargetTable": "",
        "ClientToken": ""
    });

    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": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset' \
  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  "Description": "",\n  "Ruleset": "",\n  "Tags": "",\n  "TargetTable": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDataQualityRuleset'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "Ruleset": "",
  "Tags": "",
  "TargetTable": "",
  "ClientToken": ""
] as [String : Any]

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:CatalogId ""
                                                                                               :DatabaseInput ""
                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\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: 58

{
  "CatalogId": "",
  "DatabaseInput": "",
  "Tags": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase")
  .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=AWSGlue.CreateDatabase")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseInput: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase');
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=AWSGlue.CreateDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseInput: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseInput":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseInput": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase")
  .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({CatalogId: '', DatabaseInput: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', DatabaseInput: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase');

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseInput: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseInput: '', Tags: ''}
};

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=AWSGlue.CreateDatabase';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseInput":"","Tags":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseInput": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase",
  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([
    'CatalogId' => '',
    'DatabaseInput' => '',
    'Tags' => ''
  ]),
  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=AWSGlue.CreateDatabase', [
  'body' => '{
  "CatalogId": "",
  "DatabaseInput": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseInput' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseInput' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase');
$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=AWSGlue.CreateDatabase' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseInput": "",
  "Tags": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateDatabase"

payload = {
    "CatalogId": "",
    "DatabaseInput": "",
    "Tags": ""
}
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=AWSGlue.CreateDatabase"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateDatabase")

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  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"CatalogId\": \"\",\n  \"DatabaseInput\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CatalogId": "",
        "DatabaseInput": "",
        "Tags": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseInput": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseInput": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDatabase'

import Foundation

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

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

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

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  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:EndpointName ""
                                                                                                  :RoleArn ""
                                                                                                  :SecurityGroupIds ""
                                                                                                  :SubnetId ""
                                                                                                  :PublicKey ""
                                                                                                  :PublicKeys ""
                                                                                                  :NumberOfNodes ""
                                                                                                  :WorkerType ""
                                                                                                  :GlueVersion ""
                                                                                                  :NumberOfWorkers ""
                                                                                                  :ExtraPythonLibsS3Path ""
                                                                                                  :ExtraJarsS3Path ""
                                                                                                  :SecurityConfiguration ""
                                                                                                  :Tags ""
                                                                                                  :Arguments ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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=AWSGlue.CreateDevEndpoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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=AWSGlue.CreateDevEndpoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint"

	payload := strings.NewReader("{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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: 333

{
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint")
  .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=AWSGlue.CreateDevEndpoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointName: '',
  RoleArn: '',
  SecurityGroupIds: '',
  SubnetId: '',
  PublicKey: '',
  PublicKeys: '',
  NumberOfNodes: '',
  WorkerType: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  ExtraPythonLibsS3Path: '',
  ExtraJarsS3Path: '',
  SecurityConfiguration: '',
  Tags: '',
  Arguments: ''
});

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=AWSGlue.CreateDevEndpoint');
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=AWSGlue.CreateDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointName: '',
    RoleArn: '',
    SecurityGroupIds: '',
    SubnetId: '',
    PublicKey: '',
    PublicKeys: '',
    NumberOfNodes: '',
    WorkerType: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    ExtraPythonLibsS3Path: '',
    ExtraJarsS3Path: '',
    SecurityConfiguration: '',
    Tags: '',
    Arguments: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointName":"","RoleArn":"","SecurityGroupIds":"","SubnetId":"","PublicKey":"","PublicKeys":"","NumberOfNodes":"","WorkerType":"","GlueVersion":"","NumberOfWorkers":"","ExtraPythonLibsS3Path":"","ExtraJarsS3Path":"","SecurityConfiguration":"","Tags":"","Arguments":""}'
};

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=AWSGlue.CreateDevEndpoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointName": "",\n  "RoleArn": "",\n  "SecurityGroupIds": "",\n  "SubnetId": "",\n  "PublicKey": "",\n  "PublicKeys": "",\n  "NumberOfNodes": "",\n  "WorkerType": "",\n  "GlueVersion": "",\n  "NumberOfWorkers": "",\n  "ExtraPythonLibsS3Path": "",\n  "ExtraJarsS3Path": "",\n  "SecurityConfiguration": "",\n  "Tags": "",\n  "Arguments": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint")
  .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({
  EndpointName: '',
  RoleArn: '',
  SecurityGroupIds: '',
  SubnetId: '',
  PublicKey: '',
  PublicKeys: '',
  NumberOfNodes: '',
  WorkerType: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  ExtraPythonLibsS3Path: '',
  ExtraJarsS3Path: '',
  SecurityConfiguration: '',
  Tags: '',
  Arguments: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EndpointName: '',
    RoleArn: '',
    SecurityGroupIds: '',
    SubnetId: '',
    PublicKey: '',
    PublicKeys: '',
    NumberOfNodes: '',
    WorkerType: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    ExtraPythonLibsS3Path: '',
    ExtraJarsS3Path: '',
    SecurityConfiguration: '',
    Tags: '',
    Arguments: ''
  },
  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=AWSGlue.CreateDevEndpoint');

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

req.type('json');
req.send({
  EndpointName: '',
  RoleArn: '',
  SecurityGroupIds: '',
  SubnetId: '',
  PublicKey: '',
  PublicKeys: '',
  NumberOfNodes: '',
  WorkerType: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  ExtraPythonLibsS3Path: '',
  ExtraJarsS3Path: '',
  SecurityConfiguration: '',
  Tags: '',
  Arguments: ''
});

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=AWSGlue.CreateDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointName: '',
    RoleArn: '',
    SecurityGroupIds: '',
    SubnetId: '',
    PublicKey: '',
    PublicKeys: '',
    NumberOfNodes: '',
    WorkerType: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    ExtraPythonLibsS3Path: '',
    ExtraJarsS3Path: '',
    SecurityConfiguration: '',
    Tags: '',
    Arguments: ''
  }
};

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=AWSGlue.CreateDevEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointName":"","RoleArn":"","SecurityGroupIds":"","SubnetId":"","PublicKey":"","PublicKeys":"","NumberOfNodes":"","WorkerType":"","GlueVersion":"","NumberOfWorkers":"","ExtraPythonLibsS3Path":"","ExtraJarsS3Path":"","SecurityConfiguration":"","Tags":"","Arguments":""}'
};

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 = @{ @"EndpointName": @"",
                              @"RoleArn": @"",
                              @"SecurityGroupIds": @"",
                              @"SubnetId": @"",
                              @"PublicKey": @"",
                              @"PublicKeys": @"",
                              @"NumberOfNodes": @"",
                              @"WorkerType": @"",
                              @"GlueVersion": @"",
                              @"NumberOfWorkers": @"",
                              @"ExtraPythonLibsS3Path": @"",
                              @"ExtraJarsS3Path": @"",
                              @"SecurityConfiguration": @"",
                              @"Tags": @"",
                              @"Arguments": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint"]
                                                       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=AWSGlue.CreateDevEndpoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint",
  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([
    'EndpointName' => '',
    'RoleArn' => '',
    'SecurityGroupIds' => '',
    'SubnetId' => '',
    'PublicKey' => '',
    'PublicKeys' => '',
    'NumberOfNodes' => '',
    'WorkerType' => '',
    'GlueVersion' => '',
    'NumberOfWorkers' => '',
    'ExtraPythonLibsS3Path' => '',
    'ExtraJarsS3Path' => '',
    'SecurityConfiguration' => '',
    'Tags' => '',
    'Arguments' => ''
  ]),
  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=AWSGlue.CreateDevEndpoint', [
  'body' => '{
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointName' => '',
  'RoleArn' => '',
  'SecurityGroupIds' => '',
  'SubnetId' => '',
  'PublicKey' => '',
  'PublicKeys' => '',
  'NumberOfNodes' => '',
  'WorkerType' => '',
  'GlueVersion' => '',
  'NumberOfWorkers' => '',
  'ExtraPythonLibsS3Path' => '',
  'ExtraJarsS3Path' => '',
  'SecurityConfiguration' => '',
  'Tags' => '',
  'Arguments' => ''
]));

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

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

append(json_encode([
  'EndpointName' => '',
  'RoleArn' => '',
  'SecurityGroupIds' => '',
  'SubnetId' => '',
  'PublicKey' => '',
  'PublicKeys' => '',
  'NumberOfNodes' => '',
  'WorkerType' => '',
  'GlueVersion' => '',
  'NumberOfWorkers' => '',
  'ExtraPythonLibsS3Path' => '',
  'ExtraJarsS3Path' => '',
  'SecurityConfiguration' => '',
  'Tags' => '',
  'Arguments' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint');
$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=AWSGlue.CreateDevEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
}'

import http.client

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

payload = "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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=AWSGlue.CreateDevEndpoint"

payload = {
    "EndpointName": "",
    "RoleArn": "",
    "SecurityGroupIds": "",
    "SubnetId": "",
    "PublicKey": "",
    "PublicKeys": "",
    "NumberOfNodes": "",
    "WorkerType": "",
    "GlueVersion": "",
    "NumberOfWorkers": "",
    "ExtraPythonLibsS3Path": "",
    "ExtraJarsS3Path": "",
    "SecurityConfiguration": "",
    "Tags": "",
    "Arguments": ""
}
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=AWSGlue.CreateDevEndpoint"

payload <- "{\n  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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=AWSGlue.CreateDevEndpoint")

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  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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  \"EndpointName\": \"\",\n  \"RoleArn\": \"\",\n  \"SecurityGroupIds\": \"\",\n  \"SubnetId\": \"\",\n  \"PublicKey\": \"\",\n  \"PublicKeys\": \"\",\n  \"NumberOfNodes\": \"\",\n  \"WorkerType\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"ExtraPythonLibsS3Path\": \"\",\n  \"ExtraJarsS3Path\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"Arguments\": \"\"\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=AWSGlue.CreateDevEndpoint";

    let payload = json!({
        "EndpointName": "",
        "RoleArn": "",
        "SecurityGroupIds": "",
        "SubnetId": "",
        "PublicKey": "",
        "PublicKeys": "",
        "NumberOfNodes": "",
        "WorkerType": "",
        "GlueVersion": "",
        "NumberOfWorkers": "",
        "ExtraPythonLibsS3Path": "",
        "ExtraJarsS3Path": "",
        "SecurityConfiguration": "",
        "Tags": "",
        "Arguments": ""
    });

    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 '{
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointName": "",\n  "RoleArn": "",\n  "SecurityGroupIds": "",\n  "SubnetId": "",\n  "PublicKey": "",\n  "PublicKeys": "",\n  "NumberOfNodes": "",\n  "WorkerType": "",\n  "GlueVersion": "",\n  "NumberOfWorkers": "",\n  "ExtraPythonLibsS3Path": "",\n  "ExtraJarsS3Path": "",\n  "SecurityConfiguration": "",\n  "Tags": "",\n  "Arguments": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateDevEndpoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EndpointName": "",
  "RoleArn": "",
  "SecurityGroupIds": "",
  "SubnetId": "",
  "PublicKey": "",
  "PublicKeys": "",
  "NumberOfNodes": "",
  "WorkerType": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "ExtraPythonLibsS3Path": "",
  "ExtraJarsS3Path": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "Arguments": ""
] as [String : Any]

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

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

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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob" {:headers {:x-amz-target ""}
                                                                            :content-type :json
                                                                            :form-params {:Name ""
                                                                                          :Description ""
                                                                                          :LogUri ""
                                                                                          :Role ""
                                                                                          :ExecutionProperty ""
                                                                                          :Command ""
                                                                                          :DefaultArguments ""
                                                                                          :NonOverridableArguments ""
                                                                                          :Connections ""
                                                                                          :MaxRetries ""
                                                                                          :AllocatedCapacity ""
                                                                                          :Timeout ""
                                                                                          :MaxCapacity ""
                                                                                          :SecurityConfiguration ""
                                                                                          :Tags ""
                                                                                          :NotificationProperty ""
                                                                                          :GlueVersion ""
                                                                                          :NumberOfWorkers ""
                                                                                          :WorkerType ""
                                                                                          :CodeGenConfigurationNodes ""
                                                                                          :ExecutionClass ""
                                                                                          :SourceControlDetails ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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=AWSGlue.CreateJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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=AWSGlue.CreateJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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: 506

{
  "Name": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob")
  .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=AWSGlue.CreateJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  LogUri: '',
  Role: '',
  ExecutionProperty: '',
  Command: '',
  DefaultArguments: '',
  NonOverridableArguments: '',
  Connections: '',
  MaxRetries: '',
  AllocatedCapacity: '',
  Timeout: '',
  MaxCapacity: '',
  SecurityConfiguration: '',
  Tags: '',
  NotificationProperty: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  WorkerType: '',
  CodeGenConfigurationNodes: '',
  ExecutionClass: '',
  SourceControlDetails: ''
});

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=AWSGlue.CreateJob');
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=AWSGlue.CreateJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LogUri: '',
    Role: '',
    ExecutionProperty: '',
    Command: '',
    DefaultArguments: '',
    NonOverridableArguments: '',
    Connections: '',
    MaxRetries: '',
    AllocatedCapacity: '',
    Timeout: '',
    MaxCapacity: '',
    SecurityConfiguration: '',
    Tags: '',
    NotificationProperty: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    WorkerType: '',
    CodeGenConfigurationNodes: '',
    ExecutionClass: '',
    SourceControlDetails: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LogUri":"","Role":"","ExecutionProperty":"","Command":"","DefaultArguments":"","NonOverridableArguments":"","Connections":"","MaxRetries":"","AllocatedCapacity":"","Timeout":"","MaxCapacity":"","SecurityConfiguration":"","Tags":"","NotificationProperty":"","GlueVersion":"","NumberOfWorkers":"","WorkerType":"","CodeGenConfigurationNodes":"","ExecutionClass":"","SourceControlDetails":""}'
};

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=AWSGlue.CreateJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "LogUri": "",\n  "Role": "",\n  "ExecutionProperty": "",\n  "Command": "",\n  "DefaultArguments": "",\n  "NonOverridableArguments": "",\n  "Connections": "",\n  "MaxRetries": "",\n  "AllocatedCapacity": "",\n  "Timeout": "",\n  "MaxCapacity": "",\n  "SecurityConfiguration": "",\n  "Tags": "",\n  "NotificationProperty": "",\n  "GlueVersion": "",\n  "NumberOfWorkers": "",\n  "WorkerType": "",\n  "CodeGenConfigurationNodes": "",\n  "ExecutionClass": "",\n  "SourceControlDetails": ""\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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob")
  .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: '',
  Description: '',
  LogUri: '',
  Role: '',
  ExecutionProperty: '',
  Command: '',
  DefaultArguments: '',
  NonOverridableArguments: '',
  Connections: '',
  MaxRetries: '',
  AllocatedCapacity: '',
  Timeout: '',
  MaxCapacity: '',
  SecurityConfiguration: '',
  Tags: '',
  NotificationProperty: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  WorkerType: '',
  CodeGenConfigurationNodes: '',
  ExecutionClass: '',
  SourceControlDetails: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    LogUri: '',
    Role: '',
    ExecutionProperty: '',
    Command: '',
    DefaultArguments: '',
    NonOverridableArguments: '',
    Connections: '',
    MaxRetries: '',
    AllocatedCapacity: '',
    Timeout: '',
    MaxCapacity: '',
    SecurityConfiguration: '',
    Tags: '',
    NotificationProperty: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    WorkerType: '',
    CodeGenConfigurationNodes: '',
    ExecutionClass: '',
    SourceControlDetails: ''
  },
  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=AWSGlue.CreateJob');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  LogUri: '',
  Role: '',
  ExecutionProperty: '',
  Command: '',
  DefaultArguments: '',
  NonOverridableArguments: '',
  Connections: '',
  MaxRetries: '',
  AllocatedCapacity: '',
  Timeout: '',
  MaxCapacity: '',
  SecurityConfiguration: '',
  Tags: '',
  NotificationProperty: '',
  GlueVersion: '',
  NumberOfWorkers: '',
  WorkerType: '',
  CodeGenConfigurationNodes: '',
  ExecutionClass: '',
  SourceControlDetails: ''
});

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=AWSGlue.CreateJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    LogUri: '',
    Role: '',
    ExecutionProperty: '',
    Command: '',
    DefaultArguments: '',
    NonOverridableArguments: '',
    Connections: '',
    MaxRetries: '',
    AllocatedCapacity: '',
    Timeout: '',
    MaxCapacity: '',
    SecurityConfiguration: '',
    Tags: '',
    NotificationProperty: '',
    GlueVersion: '',
    NumberOfWorkers: '',
    WorkerType: '',
    CodeGenConfigurationNodes: '',
    ExecutionClass: '',
    SourceControlDetails: ''
  }
};

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=AWSGlue.CreateJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","LogUri":"","Role":"","ExecutionProperty":"","Command":"","DefaultArguments":"","NonOverridableArguments":"","Connections":"","MaxRetries":"","AllocatedCapacity":"","Timeout":"","MaxCapacity":"","SecurityConfiguration":"","Tags":"","NotificationProperty":"","GlueVersion":"","NumberOfWorkers":"","WorkerType":"","CodeGenConfigurationNodes":"","ExecutionClass":"","SourceControlDetails":""}'
};

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": @"",
                              @"Description": @"",
                              @"LogUri": @"",
                              @"Role": @"",
                              @"ExecutionProperty": @"",
                              @"Command": @"",
                              @"DefaultArguments": @"",
                              @"NonOverridableArguments": @"",
                              @"Connections": @"",
                              @"MaxRetries": @"",
                              @"AllocatedCapacity": @"",
                              @"Timeout": @"",
                              @"MaxCapacity": @"",
                              @"SecurityConfiguration": @"",
                              @"Tags": @"",
                              @"NotificationProperty": @"",
                              @"GlueVersion": @"",
                              @"NumberOfWorkers": @"",
                              @"WorkerType": @"",
                              @"CodeGenConfigurationNodes": @"",
                              @"ExecutionClass": @"",
                              @"SourceControlDetails": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob"]
                                                       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=AWSGlue.CreateJob" 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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob",
  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' => '',
    'Description' => '',
    'LogUri' => '',
    'Role' => '',
    'ExecutionProperty' => '',
    'Command' => '',
    'DefaultArguments' => '',
    'NonOverridableArguments' => '',
    'Connections' => '',
    'MaxRetries' => '',
    'AllocatedCapacity' => '',
    'Timeout' => '',
    'MaxCapacity' => '',
    'SecurityConfiguration' => '',
    'Tags' => '',
    'NotificationProperty' => '',
    'GlueVersion' => '',
    'NumberOfWorkers' => '',
    'WorkerType' => '',
    'CodeGenConfigurationNodes' => '',
    'ExecutionClass' => '',
    'SourceControlDetails' => ''
  ]),
  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=AWSGlue.CreateJob', [
  'body' => '{
  "Name": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'LogUri' => '',
  'Role' => '',
  'ExecutionProperty' => '',
  'Command' => '',
  'DefaultArguments' => '',
  'NonOverridableArguments' => '',
  'Connections' => '',
  'MaxRetries' => '',
  'AllocatedCapacity' => '',
  'Timeout' => '',
  'MaxCapacity' => '',
  'SecurityConfiguration' => '',
  'Tags' => '',
  'NotificationProperty' => '',
  'GlueVersion' => '',
  'NumberOfWorkers' => '',
  'WorkerType' => '',
  'CodeGenConfigurationNodes' => '',
  'ExecutionClass' => '',
  'SourceControlDetails' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'LogUri' => '',
  'Role' => '',
  'ExecutionProperty' => '',
  'Command' => '',
  'DefaultArguments' => '',
  'NonOverridableArguments' => '',
  'Connections' => '',
  'MaxRetries' => '',
  'AllocatedCapacity' => '',
  'Timeout' => '',
  'MaxCapacity' => '',
  'SecurityConfiguration' => '',
  'Tags' => '',
  'NotificationProperty' => '',
  'GlueVersion' => '',
  'NumberOfWorkers' => '',
  'WorkerType' => '',
  'CodeGenConfigurationNodes' => '',
  'ExecutionClass' => '',
  'SourceControlDetails' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob');
$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=AWSGlue.CreateJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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=AWSGlue.CreateJob"

payload = {
    "Name": "",
    "Description": "",
    "LogUri": "",
    "Role": "",
    "ExecutionProperty": "",
    "Command": "",
    "DefaultArguments": "",
    "NonOverridableArguments": "",
    "Connections": "",
    "MaxRetries": "",
    "AllocatedCapacity": "",
    "Timeout": "",
    "MaxCapacity": "",
    "SecurityConfiguration": "",
    "Tags": "",
    "NotificationProperty": "",
    "GlueVersion": "",
    "NumberOfWorkers": "",
    "WorkerType": "",
    "CodeGenConfigurationNodes": "",
    "ExecutionClass": "",
    "SourceControlDetails": ""
}
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=AWSGlue.CreateJob"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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=AWSGlue.CreateJob")

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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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  \"Description\": \"\",\n  \"LogUri\": \"\",\n  \"Role\": \"\",\n  \"ExecutionProperty\": \"\",\n  \"Command\": \"\",\n  \"DefaultArguments\": \"\",\n  \"NonOverridableArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxRetries\": \"\",\n  \"AllocatedCapacity\": \"\",\n  \"Timeout\": \"\",\n  \"MaxCapacity\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"Tags\": \"\",\n  \"NotificationProperty\": \"\",\n  \"GlueVersion\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"CodeGenConfigurationNodes\": \"\",\n  \"ExecutionClass\": \"\",\n  \"SourceControlDetails\": \"\"\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=AWSGlue.CreateJob";

    let payload = json!({
        "Name": "",
        "Description": "",
        "LogUri": "",
        "Role": "",
        "ExecutionProperty": "",
        "Command": "",
        "DefaultArguments": "",
        "NonOverridableArguments": "",
        "Connections": "",
        "MaxRetries": "",
        "AllocatedCapacity": "",
        "Timeout": "",
        "MaxCapacity": "",
        "SecurityConfiguration": "",
        "Tags": "",
        "NotificationProperty": "",
        "GlueVersion": "",
        "NumberOfWorkers": "",
        "WorkerType": "",
        "CodeGenConfigurationNodes": "",
        "ExecutionClass": "",
        "SourceControlDetails": ""
    });

    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": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob' \
  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  "Description": "",\n  "LogUri": "",\n  "Role": "",\n  "ExecutionProperty": "",\n  "Command": "",\n  "DefaultArguments": "",\n  "NonOverridableArguments": "",\n  "Connections": "",\n  "MaxRetries": "",\n  "AllocatedCapacity": "",\n  "Timeout": "",\n  "MaxCapacity": "",\n  "SecurityConfiguration": "",\n  "Tags": "",\n  "NotificationProperty": "",\n  "GlueVersion": "",\n  "NumberOfWorkers": "",\n  "WorkerType": "",\n  "CodeGenConfigurationNodes": "",\n  "ExecutionClass": "",\n  "SourceControlDetails": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "LogUri": "",
  "Role": "",
  "ExecutionProperty": "",
  "Command": "",
  "DefaultArguments": "",
  "NonOverridableArguments": "",
  "Connections": "",
  "MaxRetries": "",
  "AllocatedCapacity": "",
  "Timeout": "",
  "MaxCapacity": "",
  "SecurityConfiguration": "",
  "Tags": "",
  "NotificationProperty": "",
  "GlueVersion": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "CodeGenConfigurationNodes": "",
  "ExecutionClass": "",
  "SourceControlDetails": ""
] as [String : Any]

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

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

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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:Name ""
                                                                                                  :Description ""
                                                                                                  :InputRecordTables ""
                                                                                                  :Parameters ""
                                                                                                  :Role ""
                                                                                                  :GlueVersion ""
                                                                                                  :MaxCapacity ""
                                                                                                  :WorkerType ""
                                                                                                  :NumberOfWorkers ""
                                                                                                  :Timeout ""
                                                                                                  :MaxRetries ""
                                                                                                  :Tags ""
                                                                                                  :TransformEncryption ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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=AWSGlue.CreateMLTransform"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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=AWSGlue.CreateMLTransform");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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: 265

{
  "Name": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform")
  .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=AWSGlue.CreateMLTransform")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  InputRecordTables: '',
  Parameters: '',
  Role: '',
  GlueVersion: '',
  MaxCapacity: '',
  WorkerType: '',
  NumberOfWorkers: '',
  Timeout: '',
  MaxRetries: '',
  Tags: '',
  TransformEncryption: ''
});

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=AWSGlue.CreateMLTransform');
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=AWSGlue.CreateMLTransform',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    InputRecordTables: '',
    Parameters: '',
    Role: '',
    GlueVersion: '',
    MaxCapacity: '',
    WorkerType: '',
    NumberOfWorkers: '',
    Timeout: '',
    MaxRetries: '',
    Tags: '',
    TransformEncryption: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","InputRecordTables":"","Parameters":"","Role":"","GlueVersion":"","MaxCapacity":"","WorkerType":"","NumberOfWorkers":"","Timeout":"","MaxRetries":"","Tags":"","TransformEncryption":""}'
};

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=AWSGlue.CreateMLTransform',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "InputRecordTables": "",\n  "Parameters": "",\n  "Role": "",\n  "GlueVersion": "",\n  "MaxCapacity": "",\n  "WorkerType": "",\n  "NumberOfWorkers": "",\n  "Timeout": "",\n  "MaxRetries": "",\n  "Tags": "",\n  "TransformEncryption": ""\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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform")
  .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: '',
  Description: '',
  InputRecordTables: '',
  Parameters: '',
  Role: '',
  GlueVersion: '',
  MaxCapacity: '',
  WorkerType: '',
  NumberOfWorkers: '',
  Timeout: '',
  MaxRetries: '',
  Tags: '',
  TransformEncryption: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    InputRecordTables: '',
    Parameters: '',
    Role: '',
    GlueVersion: '',
    MaxCapacity: '',
    WorkerType: '',
    NumberOfWorkers: '',
    Timeout: '',
    MaxRetries: '',
    Tags: '',
    TransformEncryption: ''
  },
  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=AWSGlue.CreateMLTransform');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  InputRecordTables: '',
  Parameters: '',
  Role: '',
  GlueVersion: '',
  MaxCapacity: '',
  WorkerType: '',
  NumberOfWorkers: '',
  Timeout: '',
  MaxRetries: '',
  Tags: '',
  TransformEncryption: ''
});

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=AWSGlue.CreateMLTransform',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    InputRecordTables: '',
    Parameters: '',
    Role: '',
    GlueVersion: '',
    MaxCapacity: '',
    WorkerType: '',
    NumberOfWorkers: '',
    Timeout: '',
    MaxRetries: '',
    Tags: '',
    TransformEncryption: ''
  }
};

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=AWSGlue.CreateMLTransform';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","InputRecordTables":"","Parameters":"","Role":"","GlueVersion":"","MaxCapacity":"","WorkerType":"","NumberOfWorkers":"","Timeout":"","MaxRetries":"","Tags":"","TransformEncryption":""}'
};

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": @"",
                              @"Description": @"",
                              @"InputRecordTables": @"",
                              @"Parameters": @"",
                              @"Role": @"",
                              @"GlueVersion": @"",
                              @"MaxCapacity": @"",
                              @"WorkerType": @"",
                              @"NumberOfWorkers": @"",
                              @"Timeout": @"",
                              @"MaxRetries": @"",
                              @"Tags": @"",
                              @"TransformEncryption": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform"]
                                                       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=AWSGlue.CreateMLTransform" 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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform",
  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' => '',
    'Description' => '',
    'InputRecordTables' => '',
    'Parameters' => '',
    'Role' => '',
    'GlueVersion' => '',
    'MaxCapacity' => '',
    'WorkerType' => '',
    'NumberOfWorkers' => '',
    'Timeout' => '',
    'MaxRetries' => '',
    'Tags' => '',
    'TransformEncryption' => ''
  ]),
  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=AWSGlue.CreateMLTransform', [
  'body' => '{
  "Name": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'InputRecordTables' => '',
  'Parameters' => '',
  'Role' => '',
  'GlueVersion' => '',
  'MaxCapacity' => '',
  'WorkerType' => '',
  'NumberOfWorkers' => '',
  'Timeout' => '',
  'MaxRetries' => '',
  'Tags' => '',
  'TransformEncryption' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'InputRecordTables' => '',
  'Parameters' => '',
  'Role' => '',
  'GlueVersion' => '',
  'MaxCapacity' => '',
  'WorkerType' => '',
  'NumberOfWorkers' => '',
  'Timeout' => '',
  'MaxRetries' => '',
  'Tags' => '',
  'TransformEncryption' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform');
$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=AWSGlue.CreateMLTransform' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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=AWSGlue.CreateMLTransform"

payload = {
    "Name": "",
    "Description": "",
    "InputRecordTables": "",
    "Parameters": "",
    "Role": "",
    "GlueVersion": "",
    "MaxCapacity": "",
    "WorkerType": "",
    "NumberOfWorkers": "",
    "Timeout": "",
    "MaxRetries": "",
    "Tags": "",
    "TransformEncryption": ""
}
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=AWSGlue.CreateMLTransform"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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=AWSGlue.CreateMLTransform")

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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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  \"Description\": \"\",\n  \"InputRecordTables\": \"\",\n  \"Parameters\": \"\",\n  \"Role\": \"\",\n  \"GlueVersion\": \"\",\n  \"MaxCapacity\": \"\",\n  \"WorkerType\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"Timeout\": \"\",\n  \"MaxRetries\": \"\",\n  \"Tags\": \"\",\n  \"TransformEncryption\": \"\"\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=AWSGlue.CreateMLTransform";

    let payload = json!({
        "Name": "",
        "Description": "",
        "InputRecordTables": "",
        "Parameters": "",
        "Role": "",
        "GlueVersion": "",
        "MaxCapacity": "",
        "WorkerType": "",
        "NumberOfWorkers": "",
        "Timeout": "",
        "MaxRetries": "",
        "Tags": "",
        "TransformEncryption": ""
    });

    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": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform' \
  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  "Description": "",\n  "InputRecordTables": "",\n  "Parameters": "",\n  "Role": "",\n  "GlueVersion": "",\n  "MaxCapacity": "",\n  "WorkerType": "",\n  "NumberOfWorkers": "",\n  "Timeout": "",\n  "MaxRetries": "",\n  "Tags": "",\n  "TransformEncryption": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateMLTransform'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "InputRecordTables": "",
  "Parameters": "",
  "Role": "",
  "GlueVersion": "",
  "MaxCapacity": "",
  "WorkerType": "",
  "NumberOfWorkers": "",
  "Timeout": "",
  "MaxRetries": "",
  "Tags": "",
  "TransformEncryption": ""
] as [String : Any]

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:CatalogId ""
                                                                                                :DatabaseName ""
                                                                                                :TableName ""
                                                                                                :PartitionInput ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInput": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition")
  .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=AWSGlue.CreatePartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionInput: ''
});

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=AWSGlue.CreatePartition');
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=AWSGlue.CreatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionInput: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionInput":""}'
};

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=AWSGlue.CreatePartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionInput": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition")
  .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({CatalogId: '', DatabaseName: '', TableName: '', PartitionInput: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionInput: ''
});

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=AWSGlue.CreatePartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionInput: ''}
};

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=AWSGlue.CreatePartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionInput":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionInput": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionInput' => ''
  ]),
  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=AWSGlue.CreatePartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInput": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionInput' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionInput' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition');
$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=AWSGlue.CreatePartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInput": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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=AWSGlue.CreatePartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionInput": ""
}
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=AWSGlue.CreatePartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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=AWSGlue.CreatePartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionInput\": \"\"\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=AWSGlue.CreatePartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionInput": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionInput": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionInput": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartition'

import Foundation

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

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

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

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:CatalogId ""
                                                                                                     :DatabaseName ""
                                                                                                     :TableName ""
                                                                                                     :PartitionIndex ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionIndex": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex")
  .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=AWSGlue.CreatePartitionIndex")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionIndex: ''
});

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=AWSGlue.CreatePartitionIndex');
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=AWSGlue.CreatePartitionIndex',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionIndex: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionIndex":""}'
};

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=AWSGlue.CreatePartitionIndex',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionIndex": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex")
  .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({CatalogId: '', DatabaseName: '', TableName: '', PartitionIndex: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionIndex: ''
});

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=AWSGlue.CreatePartitionIndex',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', PartitionIndex: ''}
};

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=AWSGlue.CreatePartitionIndex';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionIndex":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionIndex": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionIndex' => ''
  ]),
  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=AWSGlue.CreatePartitionIndex', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionIndex": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionIndex' => ''
]));

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

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

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionIndex' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex');
$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=AWSGlue.CreatePartitionIndex' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionIndex": ""
}'

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

import http.client

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

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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=AWSGlue.CreatePartitionIndex"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionIndex": ""
}
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=AWSGlue.CreatePartitionIndex"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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=AWSGlue.CreatePartitionIndex")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionIndex\": \"\"\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=AWSGlue.CreatePartitionIndex";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionIndex": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionIndex": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionIndex": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreatePartitionIndex'

import Foundation

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

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

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

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  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:RegistryName ""
                                                                                               :Description ""
                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry"

	payload := strings.NewReader("{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\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

{
  "RegistryName": "",
  "Description": "",
  "Tags": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry")
  .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=AWSGlue.CreateRegistry")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  RegistryName: '',
  Description: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry');
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=AWSGlue.CreateRegistry',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RegistryName: '', Description: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RegistryName":"","Description":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RegistryName": "",\n  "Description": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry")
  .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({RegistryName: '', Description: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {RegistryName: '', Description: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry');

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

req.type('json');
req.send({
  RegistryName: '',
  Description: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RegistryName: '', Description: '', Tags: ''}
};

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=AWSGlue.CreateRegistry';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RegistryName":"","Description":"","Tags":""}'
};

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 = @{ @"RegistryName": @"",
                              @"Description": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry",
  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([
    'RegistryName' => '',
    'Description' => '',
    'Tags' => ''
  ]),
  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=AWSGlue.CreateRegistry', [
  'body' => '{
  "RegistryName": "",
  "Description": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RegistryName' => '',
  'Description' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'RegistryName' => '',
  'Description' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry');
$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=AWSGlue.CreateRegistry' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RegistryName": "",
  "Description": "",
  "Tags": ""
}'

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

import http.client

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

payload = "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateRegistry"

payload = {
    "RegistryName": "",
    "Description": "",
    "Tags": ""
}
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=AWSGlue.CreateRegistry"

payload <- "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\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=AWSGlue.CreateRegistry")

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  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"RegistryName\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "RegistryName": "",
        "Description": "",
        "Tags": ""
    });

    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 '{
  "RegistryName": "",
  "Description": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "RegistryName": "",\n  "Description": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateRegistry'

import Foundation

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

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

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

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  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema" {:headers {:x-amz-target ""}
                                                                               :content-type :json
                                                                               :form-params {:RegistryId ""
                                                                                             :SchemaName ""
                                                                                             :DataFormat ""
                                                                                             :Compatibility ""
                                                                                             :Description ""
                                                                                             :Tags ""
                                                                                             :SchemaDefinition ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema"

	payload := strings.NewReader("{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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: 146

{
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema")
  .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=AWSGlue.CreateSchema")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  RegistryId: '',
  SchemaName: '',
  DataFormat: '',
  Compatibility: '',
  Description: '',
  Tags: '',
  SchemaDefinition: ''
});

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=AWSGlue.CreateSchema');
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=AWSGlue.CreateSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    RegistryId: '',
    SchemaName: '',
    DataFormat: '',
    Compatibility: '',
    Description: '',
    Tags: '',
    SchemaDefinition: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RegistryId":"","SchemaName":"","DataFormat":"","Compatibility":"","Description":"","Tags":"","SchemaDefinition":""}'
};

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=AWSGlue.CreateSchema',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RegistryId": "",\n  "SchemaName": "",\n  "DataFormat": "",\n  "Compatibility": "",\n  "Description": "",\n  "Tags": "",\n  "SchemaDefinition": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema")
  .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({
  RegistryId: '',
  SchemaName: '',
  DataFormat: '',
  Compatibility: '',
  Description: '',
  Tags: '',
  SchemaDefinition: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    RegistryId: '',
    SchemaName: '',
    DataFormat: '',
    Compatibility: '',
    Description: '',
    Tags: '',
    SchemaDefinition: ''
  },
  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=AWSGlue.CreateSchema');

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

req.type('json');
req.send({
  RegistryId: '',
  SchemaName: '',
  DataFormat: '',
  Compatibility: '',
  Description: '',
  Tags: '',
  SchemaDefinition: ''
});

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=AWSGlue.CreateSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    RegistryId: '',
    SchemaName: '',
    DataFormat: '',
    Compatibility: '',
    Description: '',
    Tags: '',
    SchemaDefinition: ''
  }
};

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=AWSGlue.CreateSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RegistryId":"","SchemaName":"","DataFormat":"","Compatibility":"","Description":"","Tags":"","SchemaDefinition":""}'
};

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 = @{ @"RegistryId": @"",
                              @"SchemaName": @"",
                              @"DataFormat": @"",
                              @"Compatibility": @"",
                              @"Description": @"",
                              @"Tags": @"",
                              @"SchemaDefinition": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema",
  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([
    'RegistryId' => '',
    'SchemaName' => '',
    'DataFormat' => '',
    'Compatibility' => '',
    'Description' => '',
    'Tags' => '',
    'SchemaDefinition' => ''
  ]),
  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=AWSGlue.CreateSchema', [
  'body' => '{
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RegistryId' => '',
  'SchemaName' => '',
  'DataFormat' => '',
  'Compatibility' => '',
  'Description' => '',
  'Tags' => '',
  'SchemaDefinition' => ''
]));

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

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

append(json_encode([
  'RegistryId' => '',
  'SchemaName' => '',
  'DataFormat' => '',
  'Compatibility' => '',
  'Description' => '',
  'Tags' => '',
  'SchemaDefinition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema');
$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=AWSGlue.CreateSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
}'

import http.client

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

payload = "{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CreateSchema"

payload = {
    "RegistryId": "",
    "SchemaName": "",
    "DataFormat": "",
    "Compatibility": "",
    "Description": "",
    "Tags": "",
    "SchemaDefinition": ""
}
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=AWSGlue.CreateSchema"

payload <- "{\n  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CreateSchema")

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  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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  \"RegistryId\": \"\",\n  \"SchemaName\": \"\",\n  \"DataFormat\": \"\",\n  \"Compatibility\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\",\n  \"SchemaDefinition\": \"\"\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=AWSGlue.CreateSchema";

    let payload = json!({
        "RegistryId": "",
        "SchemaName": "",
        "DataFormat": "",
        "Compatibility": "",
        "Description": "",
        "Tags": "",
        "SchemaDefinition": ""
    });

    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 '{
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "RegistryId": "",\n  "SchemaName": "",\n  "DataFormat": "",\n  "Compatibility": "",\n  "Description": "",\n  "Tags": "",\n  "SchemaDefinition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSchema'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "RegistryId": "",
  "SchemaName": "",
  "DataFormat": "",
  "Compatibility": "",
  "Description": "",
  "Tags": "",
  "SchemaDefinition": ""
] as [String : Any]

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

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

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  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript" {:headers {:x-amz-target ""}
                                                                               :content-type :json
                                                                               :form-params {:DagNodes ""
                                                                                             :DagEdges ""
                                                                                             :Language ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript"

	payload := strings.NewReader("{\n  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\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

{
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
}

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

client.close();

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

const data = JSON.stringify({
  DagNodes: '',
  DagEdges: '',
  Language: ''
});

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=AWSGlue.CreateScript');
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=AWSGlue.CreateScript',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DagNodes: '', DagEdges: '', Language: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DagNodes":"","DagEdges":"","Language":""}'
};

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=AWSGlue.CreateScript',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DagNodes": "",\n  "DagEdges": "",\n  "Language": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript")
  .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({DagNodes: '', DagEdges: '', Language: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DagNodes: '', DagEdges: '', Language: ''},
  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=AWSGlue.CreateScript');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DagNodes: '',
  DagEdges: '',
  Language: ''
});

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=AWSGlue.CreateScript',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DagNodes: '', DagEdges: '', Language: ''}
};

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=AWSGlue.CreateScript';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DagNodes":"","DagEdges":"","Language":""}'
};

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 = @{ @"DagNodes": @"",
                              @"DagEdges": @"",
                              @"Language": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript"]
                                                       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=AWSGlue.CreateScript" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript",
  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([
    'DagNodes' => '',
    'DagEdges' => '',
    'Language' => ''
  ]),
  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=AWSGlue.CreateScript', [
  'body' => '{
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DagNodes' => '',
  'DagEdges' => '',
  'Language' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DagNodes' => '',
  'DagEdges' => '',
  'Language' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript');
$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=AWSGlue.CreateScript' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\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=AWSGlue.CreateScript"

payload = {
    "DagNodes": "",
    "DagEdges": "",
    "Language": ""
}
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=AWSGlue.CreateScript"

payload <- "{\n  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\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=AWSGlue.CreateScript")

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  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\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  \"DagNodes\": \"\",\n  \"DagEdges\": \"\",\n  \"Language\": \"\"\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=AWSGlue.CreateScript";

    let payload = json!({
        "DagNodes": "",
        "DagEdges": "",
        "Language": ""
    });

    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 '{
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DagNodes": "",\n  "DagEdges": "",\n  "Language": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DagNodes": "",
  "DagEdges": "",
  "Language": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateScript")! 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=AWSGlue.CreateSecurityConfiguration");

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  \"EncryptionConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:Name ""
                                                                                                            :EncryptionConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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=AWSGlue.CreateSecurityConfiguration"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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=AWSGlue.CreateSecurityConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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

{
  "Name": "",
  "EncryptionConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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  \"EncryptionConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration")
  .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=AWSGlue.CreateSecurityConfiguration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  EncryptionConfiguration: ''
});

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=AWSGlue.CreateSecurityConfiguration');
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=AWSGlue.CreateSecurityConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', EncryptionConfiguration: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","EncryptionConfiguration":""}'
};

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=AWSGlue.CreateSecurityConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "EncryptionConfiguration": ""\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  \"EncryptionConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration")
  .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: '', EncryptionConfiguration: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', EncryptionConfiguration: ''},
  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=AWSGlue.CreateSecurityConfiguration');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  EncryptionConfiguration: ''
});

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=AWSGlue.CreateSecurityConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', EncryptionConfiguration: ''}
};

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=AWSGlue.CreateSecurityConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","EncryptionConfiguration":""}'
};

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": @"",
                              @"EncryptionConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration"]
                                                       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=AWSGlue.CreateSecurityConfiguration" 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  \"EncryptionConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration",
  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' => '',
    'EncryptionConfiguration' => ''
  ]),
  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=AWSGlue.CreateSecurityConfiguration', [
  'body' => '{
  "Name": "",
  "EncryptionConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'EncryptionConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'EncryptionConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration');
$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=AWSGlue.CreateSecurityConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "EncryptionConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "EncryptionConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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=AWSGlue.CreateSecurityConfiguration"

payload = {
    "Name": "",
    "EncryptionConfiguration": ""
}
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=AWSGlue.CreateSecurityConfiguration"

payload <- "{\n  \"Name\": \"\",\n  \"EncryptionConfiguration\": \"\"\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=AWSGlue.CreateSecurityConfiguration")

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  \"EncryptionConfiguration\": \"\"\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  \"EncryptionConfiguration\": \"\"\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=AWSGlue.CreateSecurityConfiguration";

    let payload = json!({
        "Name": "",
        "EncryptionConfiguration": ""
    });

    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": "",
  "EncryptionConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration' \
  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  "EncryptionConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "EncryptionConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSecurityConfiguration")! 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=AWSGlue.CreateSession");

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  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:Id ""
                                                                                              :Description ""
                                                                                              :Role ""
                                                                                              :Command ""
                                                                                              :Timeout ""
                                                                                              :IdleTimeout ""
                                                                                              :DefaultArguments ""
                                                                                              :Connections ""
                                                                                              :MaxCapacity ""
                                                                                              :NumberOfWorkers ""
                                                                                              :WorkerType ""
                                                                                              :SecurityConfiguration ""
                                                                                              :GlueVersion ""
                                                                                              :Tags ""
                                                                                              :RequestOrigin ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CreateSession"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CreateSession");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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: 306

{
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession")
  .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=AWSGlue.CreateSession")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  Description: '',
  Role: '',
  Command: '',
  Timeout: '',
  IdleTimeout: '',
  DefaultArguments: '',
  Connections: '',
  MaxCapacity: '',
  NumberOfWorkers: '',
  WorkerType: '',
  SecurityConfiguration: '',
  GlueVersion: '',
  Tags: '',
  RequestOrigin: ''
});

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=AWSGlue.CreateSession');
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=AWSGlue.CreateSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Id: '',
    Description: '',
    Role: '',
    Command: '',
    Timeout: '',
    IdleTimeout: '',
    DefaultArguments: '',
    Connections: '',
    MaxCapacity: '',
    NumberOfWorkers: '',
    WorkerType: '',
    SecurityConfiguration: '',
    GlueVersion: '',
    Tags: '',
    RequestOrigin: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Description":"","Role":"","Command":"","Timeout":"","IdleTimeout":"","DefaultArguments":"","Connections":"","MaxCapacity":"","NumberOfWorkers":"","WorkerType":"","SecurityConfiguration":"","GlueVersion":"","Tags":"","RequestOrigin":""}'
};

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=AWSGlue.CreateSession',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "Description": "",\n  "Role": "",\n  "Command": "",\n  "Timeout": "",\n  "IdleTimeout": "",\n  "DefaultArguments": "",\n  "Connections": "",\n  "MaxCapacity": "",\n  "NumberOfWorkers": "",\n  "WorkerType": "",\n  "SecurityConfiguration": "",\n  "GlueVersion": "",\n  "Tags": "",\n  "RequestOrigin": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession")
  .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({
  Id: '',
  Description: '',
  Role: '',
  Command: '',
  Timeout: '',
  IdleTimeout: '',
  DefaultArguments: '',
  Connections: '',
  MaxCapacity: '',
  NumberOfWorkers: '',
  WorkerType: '',
  SecurityConfiguration: '',
  GlueVersion: '',
  Tags: '',
  RequestOrigin: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Id: '',
    Description: '',
    Role: '',
    Command: '',
    Timeout: '',
    IdleTimeout: '',
    DefaultArguments: '',
    Connections: '',
    MaxCapacity: '',
    NumberOfWorkers: '',
    WorkerType: '',
    SecurityConfiguration: '',
    GlueVersion: '',
    Tags: '',
    RequestOrigin: ''
  },
  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=AWSGlue.CreateSession');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  Description: '',
  Role: '',
  Command: '',
  Timeout: '',
  IdleTimeout: '',
  DefaultArguments: '',
  Connections: '',
  MaxCapacity: '',
  NumberOfWorkers: '',
  WorkerType: '',
  SecurityConfiguration: '',
  GlueVersion: '',
  Tags: '',
  RequestOrigin: ''
});

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=AWSGlue.CreateSession',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Id: '',
    Description: '',
    Role: '',
    Command: '',
    Timeout: '',
    IdleTimeout: '',
    DefaultArguments: '',
    Connections: '',
    MaxCapacity: '',
    NumberOfWorkers: '',
    WorkerType: '',
    SecurityConfiguration: '',
    GlueVersion: '',
    Tags: '',
    RequestOrigin: ''
  }
};

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=AWSGlue.CreateSession';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Id":"","Description":"","Role":"","Command":"","Timeout":"","IdleTimeout":"","DefaultArguments":"","Connections":"","MaxCapacity":"","NumberOfWorkers":"","WorkerType":"","SecurityConfiguration":"","GlueVersion":"","Tags":"","RequestOrigin":""}'
};

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 = @{ @"Id": @"",
                              @"Description": @"",
                              @"Role": @"",
                              @"Command": @"",
                              @"Timeout": @"",
                              @"IdleTimeout": @"",
                              @"DefaultArguments": @"",
                              @"Connections": @"",
                              @"MaxCapacity": @"",
                              @"NumberOfWorkers": @"",
                              @"WorkerType": @"",
                              @"SecurityConfiguration": @"",
                              @"GlueVersion": @"",
                              @"Tags": @"",
                              @"RequestOrigin": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession"]
                                                       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=AWSGlue.CreateSession" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession",
  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([
    'Id' => '',
    'Description' => '',
    'Role' => '',
    'Command' => '',
    'Timeout' => '',
    'IdleTimeout' => '',
    'DefaultArguments' => '',
    'Connections' => '',
    'MaxCapacity' => '',
    'NumberOfWorkers' => '',
    'WorkerType' => '',
    'SecurityConfiguration' => '',
    'GlueVersion' => '',
    'Tags' => '',
    'RequestOrigin' => ''
  ]),
  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=AWSGlue.CreateSession', [
  'body' => '{
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'Description' => '',
  'Role' => '',
  'Command' => '',
  'Timeout' => '',
  'IdleTimeout' => '',
  'DefaultArguments' => '',
  'Connections' => '',
  'MaxCapacity' => '',
  'NumberOfWorkers' => '',
  'WorkerType' => '',
  'SecurityConfiguration' => '',
  'GlueVersion' => '',
  'Tags' => '',
  'RequestOrigin' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'Description' => '',
  'Role' => '',
  'Command' => '',
  'Timeout' => '',
  'IdleTimeout' => '',
  'DefaultArguments' => '',
  'Connections' => '',
  'MaxCapacity' => '',
  'NumberOfWorkers' => '',
  'WorkerType' => '',
  'SecurityConfiguration' => '',
  'GlueVersion' => '',
  'Tags' => '',
  'RequestOrigin' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession');
$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=AWSGlue.CreateSession' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CreateSession"

payload = {
    "Id": "",
    "Description": "",
    "Role": "",
    "Command": "",
    "Timeout": "",
    "IdleTimeout": "",
    "DefaultArguments": "",
    "Connections": "",
    "MaxCapacity": "",
    "NumberOfWorkers": "",
    "WorkerType": "",
    "SecurityConfiguration": "",
    "GlueVersion": "",
    "Tags": "",
    "RequestOrigin": ""
}
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=AWSGlue.CreateSession"

payload <- "{\n  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CreateSession")

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  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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  \"Id\": \"\",\n  \"Description\": \"\",\n  \"Role\": \"\",\n  \"Command\": \"\",\n  \"Timeout\": \"\",\n  \"IdleTimeout\": \"\",\n  \"DefaultArguments\": \"\",\n  \"Connections\": \"\",\n  \"MaxCapacity\": \"\",\n  \"NumberOfWorkers\": \"\",\n  \"WorkerType\": \"\",\n  \"SecurityConfiguration\": \"\",\n  \"GlueVersion\": \"\",\n  \"Tags\": \"\",\n  \"RequestOrigin\": \"\"\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=AWSGlue.CreateSession";

    let payload = json!({
        "Id": "",
        "Description": "",
        "Role": "",
        "Command": "",
        "Timeout": "",
        "IdleTimeout": "",
        "DefaultArguments": "",
        "Connections": "",
        "MaxCapacity": "",
        "NumberOfWorkers": "",
        "WorkerType": "",
        "SecurityConfiguration": "",
        "GlueVersion": "",
        "Tags": "",
        "RequestOrigin": ""
    });

    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 '{
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "Description": "",\n  "Role": "",\n  "Command": "",\n  "Timeout": "",\n  "IdleTimeout": "",\n  "DefaultArguments": "",\n  "Connections": "",\n  "MaxCapacity": "",\n  "NumberOfWorkers": "",\n  "WorkerType": "",\n  "SecurityConfiguration": "",\n  "GlueVersion": "",\n  "Tags": "",\n  "RequestOrigin": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Id": "",
  "Description": "",
  "Role": "",
  "Command": "",
  "Timeout": "",
  "IdleTimeout": "",
  "DefaultArguments": "",
  "Connections": "",
  "MaxCapacity": "",
  "NumberOfWorkers": "",
  "WorkerType": "",
  "SecurityConfiguration": "",
  "GlueVersion": "",
  "Tags": "",
  "RequestOrigin": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateSession")! 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=AWSGlue.CreateTable");

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable" {:headers {:x-amz-target ""}
                                                                              :content-type :json
                                                                              :form-params {:CatalogId ""
                                                                                            :DatabaseName ""
                                                                                            :TableInput ""
                                                                                            :PartitionIndexes ""
                                                                                            :TransactionId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.CreateTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.CreateTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable")
  .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=AWSGlue.CreateTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableInput: '',
  PartitionIndexes: '',
  TransactionId: ''
});

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=AWSGlue.CreateTable');
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=AWSGlue.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CatalogId: '',
    DatabaseName: '',
    TableInput: '',
    PartitionIndexes: '',
    TransactionId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableInput":"","PartitionIndexes":"","TransactionId":""}'
};

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=AWSGlue.CreateTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableInput": "",\n  "PartitionIndexes": "",\n  "TransactionId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable")
  .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({
  CatalogId: '',
  DatabaseName: '',
  TableInput: '',
  PartitionIndexes: '',
  TransactionId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    CatalogId: '',
    DatabaseName: '',
    TableInput: '',
    PartitionIndexes: '',
    TransactionId: ''
  },
  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=AWSGlue.CreateTable');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableInput: '',
  PartitionIndexes: '',
  TransactionId: ''
});

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=AWSGlue.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CatalogId: '',
    DatabaseName: '',
    TableInput: '',
    PartitionIndexes: '',
    TransactionId: ''
  }
};

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=AWSGlue.CreateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableInput":"","PartitionIndexes":"","TransactionId":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableInput": @"",
                              @"PartitionIndexes": @"",
                              @"TransactionId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable"]
                                                       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=AWSGlue.CreateTable" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableInput' => '',
    'PartitionIndexes' => '',
    'TransactionId' => ''
  ]),
  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=AWSGlue.CreateTable', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableInput' => '',
  'PartitionIndexes' => '',
  'TransactionId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableInput' => '',
  'PartitionIndexes' => '',
  'TransactionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable');
$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=AWSGlue.CreateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.CreateTable"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableInput": "",
    "PartitionIndexes": "",
    "TransactionId": ""
}
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=AWSGlue.CreateTable"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.CreateTable")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableInput\": \"\",\n  \"PartitionIndexes\": \"\",\n  \"TransactionId\": \"\"\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=AWSGlue.CreateTable";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableInput": "",
        "PartitionIndexes": "",
        "TransactionId": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableInput": "",\n  "PartitionIndexes": "",\n  "TransactionId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "DatabaseName": "",
  "TableInput": "",
  "PartitionIndexes": "",
  "TransactionId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTable")! 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=AWSGlue.CreateTrigger");

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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:Name ""
                                                                                              :WorkflowName ""
                                                                                              :Type ""
                                                                                              :Schedule ""
                                                                                              :Predicate ""
                                                                                              :Actions ""
                                                                                              :Description ""
                                                                                              :StartOnCreation ""
                                                                                              :Tags ""
                                                                                              :EventBatchingCondition ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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=AWSGlue.CreateTrigger"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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=AWSGlue.CreateTrigger");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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: 198

{
  "Name": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger")
  .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=AWSGlue.CreateTrigger")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  WorkflowName: '',
  Type: '',
  Schedule: '',
  Predicate: '',
  Actions: '',
  Description: '',
  StartOnCreation: '',
  Tags: '',
  EventBatchingCondition: ''
});

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=AWSGlue.CreateTrigger');
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=AWSGlue.CreateTrigger',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    WorkflowName: '',
    Type: '',
    Schedule: '',
    Predicate: '',
    Actions: '',
    Description: '',
    StartOnCreation: '',
    Tags: '',
    EventBatchingCondition: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","WorkflowName":"","Type":"","Schedule":"","Predicate":"","Actions":"","Description":"","StartOnCreation":"","Tags":"","EventBatchingCondition":""}'
};

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=AWSGlue.CreateTrigger',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "WorkflowName": "",\n  "Type": "",\n  "Schedule": "",\n  "Predicate": "",\n  "Actions": "",\n  "Description": "",\n  "StartOnCreation": "",\n  "Tags": "",\n  "EventBatchingCondition": ""\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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger")
  .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: '',
  WorkflowName: '',
  Type: '',
  Schedule: '',
  Predicate: '',
  Actions: '',
  Description: '',
  StartOnCreation: '',
  Tags: '',
  EventBatchingCondition: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    WorkflowName: '',
    Type: '',
    Schedule: '',
    Predicate: '',
    Actions: '',
    Description: '',
    StartOnCreation: '',
    Tags: '',
    EventBatchingCondition: ''
  },
  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=AWSGlue.CreateTrigger');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  WorkflowName: '',
  Type: '',
  Schedule: '',
  Predicate: '',
  Actions: '',
  Description: '',
  StartOnCreation: '',
  Tags: '',
  EventBatchingCondition: ''
});

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=AWSGlue.CreateTrigger',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    WorkflowName: '',
    Type: '',
    Schedule: '',
    Predicate: '',
    Actions: '',
    Description: '',
    StartOnCreation: '',
    Tags: '',
    EventBatchingCondition: ''
  }
};

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=AWSGlue.CreateTrigger';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","WorkflowName":"","Type":"","Schedule":"","Predicate":"","Actions":"","Description":"","StartOnCreation":"","Tags":"","EventBatchingCondition":""}'
};

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": @"",
                              @"WorkflowName": @"",
                              @"Type": @"",
                              @"Schedule": @"",
                              @"Predicate": @"",
                              @"Actions": @"",
                              @"Description": @"",
                              @"StartOnCreation": @"",
                              @"Tags": @"",
                              @"EventBatchingCondition": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger"]
                                                       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=AWSGlue.CreateTrigger" 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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger",
  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' => '',
    'WorkflowName' => '',
    'Type' => '',
    'Schedule' => '',
    'Predicate' => '',
    'Actions' => '',
    'Description' => '',
    'StartOnCreation' => '',
    'Tags' => '',
    'EventBatchingCondition' => ''
  ]),
  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=AWSGlue.CreateTrigger', [
  'body' => '{
  "Name": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'WorkflowName' => '',
  'Type' => '',
  'Schedule' => '',
  'Predicate' => '',
  'Actions' => '',
  'Description' => '',
  'StartOnCreation' => '',
  'Tags' => '',
  'EventBatchingCondition' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'WorkflowName' => '',
  'Type' => '',
  'Schedule' => '',
  'Predicate' => '',
  'Actions' => '',
  'Description' => '',
  'StartOnCreation' => '',
  'Tags' => '',
  'EventBatchingCondition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger');
$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=AWSGlue.CreateTrigger' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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=AWSGlue.CreateTrigger"

payload = {
    "Name": "",
    "WorkflowName": "",
    "Type": "",
    "Schedule": "",
    "Predicate": "",
    "Actions": "",
    "Description": "",
    "StartOnCreation": "",
    "Tags": "",
    "EventBatchingCondition": ""
}
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=AWSGlue.CreateTrigger"

payload <- "{\n  \"Name\": \"\",\n  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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=AWSGlue.CreateTrigger")

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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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  \"WorkflowName\": \"\",\n  \"Type\": \"\",\n  \"Schedule\": \"\",\n  \"Predicate\": \"\",\n  \"Actions\": \"\",\n  \"Description\": \"\",\n  \"StartOnCreation\": \"\",\n  \"Tags\": \"\",\n  \"EventBatchingCondition\": \"\"\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=AWSGlue.CreateTrigger";

    let payload = json!({
        "Name": "",
        "WorkflowName": "",
        "Type": "",
        "Schedule": "",
        "Predicate": "",
        "Actions": "",
        "Description": "",
        "StartOnCreation": "",
        "Tags": "",
        "EventBatchingCondition": ""
    });

    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": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger' \
  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  "WorkflowName": "",\n  "Type": "",\n  "Schedule": "",\n  "Predicate": "",\n  "Actions": "",\n  "Description": "",\n  "StartOnCreation": "",\n  "Tags": "",\n  "EventBatchingCondition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "WorkflowName": "",
  "Type": "",
  "Schedule": "",
  "Predicate": "",
  "Actions": "",
  "Description": "",
  "StartOnCreation": "",
  "Tags": "",
  "EventBatchingCondition": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateTrigger")! 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=AWSGlue.CreateUserDefinedFunction");

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:CatalogId ""
                                                                                                          :DatabaseName ""
                                                                                                          :FunctionInput ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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=AWSGlue.CreateUserDefinedFunction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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=AWSGlue.CreateUserDefinedFunction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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: 66

{
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction")
  .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=AWSGlue.CreateUserDefinedFunction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  FunctionInput: ''
});

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=AWSGlue.CreateUserDefinedFunction');
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=AWSGlue.CreateUserDefinedFunction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', FunctionInput: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","FunctionInput":""}'
};

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=AWSGlue.CreateUserDefinedFunction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "FunctionInput": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction")
  .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({CatalogId: '', DatabaseName: '', FunctionInput: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', DatabaseName: '', FunctionInput: ''},
  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=AWSGlue.CreateUserDefinedFunction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  FunctionInput: ''
});

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=AWSGlue.CreateUserDefinedFunction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', FunctionInput: ''}
};

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=AWSGlue.CreateUserDefinedFunction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","FunctionInput":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"FunctionInput": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction"]
                                                       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=AWSGlue.CreateUserDefinedFunction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'FunctionInput' => ''
  ]),
  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=AWSGlue.CreateUserDefinedFunction', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'FunctionInput' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'FunctionInput' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction');
$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=AWSGlue.CreateUserDefinedFunction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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=AWSGlue.CreateUserDefinedFunction"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "FunctionInput": ""
}
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=AWSGlue.CreateUserDefinedFunction"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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=AWSGlue.CreateUserDefinedFunction")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"FunctionInput\": \"\"\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=AWSGlue.CreateUserDefinedFunction";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "FunctionInput": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "FunctionInput": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "DatabaseName": "",
  "FunctionInput": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateUserDefinedFunction")! 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=AWSGlue.CreateWorkflow");

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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:Name ""
                                                                                               :Description ""
                                                                                               :DefaultRunProperties ""
                                                                                               :Tags ""
                                                                                               :MaxConcurrentRuns ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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=AWSGlue.CreateWorkflow"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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=AWSGlue.CreateWorkflow");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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: 108

{
  "Name": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow")
  .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=AWSGlue.CreateWorkflow")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  DefaultRunProperties: '',
  Tags: '',
  MaxConcurrentRuns: ''
});

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=AWSGlue.CreateWorkflow');
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=AWSGlue.CreateWorkflow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DefaultRunProperties: '',
    Tags: '',
    MaxConcurrentRuns: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DefaultRunProperties":"","Tags":"","MaxConcurrentRuns":""}'
};

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=AWSGlue.CreateWorkflow',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "DefaultRunProperties": "",\n  "Tags": "",\n  "MaxConcurrentRuns": ""\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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow")
  .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: '',
  Description: '',
  DefaultRunProperties: '',
  Tags: '',
  MaxConcurrentRuns: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    DefaultRunProperties: '',
    Tags: '',
    MaxConcurrentRuns: ''
  },
  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=AWSGlue.CreateWorkflow');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  Description: '',
  DefaultRunProperties: '',
  Tags: '',
  MaxConcurrentRuns: ''
});

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=AWSGlue.CreateWorkflow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    DefaultRunProperties: '',
    Tags: '',
    MaxConcurrentRuns: ''
  }
};

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=AWSGlue.CreateWorkflow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","DefaultRunProperties":"","Tags":"","MaxConcurrentRuns":""}'
};

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": @"",
                              @"Description": @"",
                              @"DefaultRunProperties": @"",
                              @"Tags": @"",
                              @"MaxConcurrentRuns": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow"]
                                                       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=AWSGlue.CreateWorkflow" 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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow",
  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' => '',
    'Description' => '',
    'DefaultRunProperties' => '',
    'Tags' => '',
    'MaxConcurrentRuns' => ''
  ]),
  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=AWSGlue.CreateWorkflow', [
  'body' => '{
  "Name": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'DefaultRunProperties' => '',
  'Tags' => '',
  'MaxConcurrentRuns' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'Description' => '',
  'DefaultRunProperties' => '',
  'Tags' => '',
  'MaxConcurrentRuns' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow');
$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=AWSGlue.CreateWorkflow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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=AWSGlue.CreateWorkflow"

payload = {
    "Name": "",
    "Description": "",
    "DefaultRunProperties": "",
    "Tags": "",
    "MaxConcurrentRuns": ""
}
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=AWSGlue.CreateWorkflow"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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=AWSGlue.CreateWorkflow")

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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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  \"Description\": \"\",\n  \"DefaultRunProperties\": \"\",\n  \"Tags\": \"\",\n  \"MaxConcurrentRuns\": \"\"\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=AWSGlue.CreateWorkflow";

    let payload = json!({
        "Name": "",
        "Description": "",
        "DefaultRunProperties": "",
        "Tags": "",
        "MaxConcurrentRuns": ""
    });

    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": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow' \
  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  "Description": "",\n  "DefaultRunProperties": "",\n  "Tags": "",\n  "MaxConcurrentRuns": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "DefaultRunProperties": "",
  "Tags": "",
  "MaxConcurrentRuns": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.CreateWorkflow")! 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=AWSGlue.DeleteBlueprint");

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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteBlueprint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\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=AWSGlue.DeleteBlueprint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint")
  .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=AWSGlue.DeleteBlueprint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

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=AWSGlue.DeleteBlueprint');
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=AWSGlue.DeleteBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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=AWSGlue.DeleteBlueprint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  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=AWSGlue.DeleteBlueprint');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

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=AWSGlue.DeleteBlueprint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=AWSGlue.DeleteBlueprint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint"]
                                                       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=AWSGlue.DeleteBlueprint" 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}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint",
  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' => ''
  ]),
  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=AWSGlue.DeleteBlueprint', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint');
$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=AWSGlue.DeleteBlueprint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteBlueprint"

payload = { "Name": "" }
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=AWSGlue.DeleteBlueprint"

payload <- "{\n  \"Name\": \"\"\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=AWSGlue.DeleteBlueprint")

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}"

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}"
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=AWSGlue.DeleteBlueprint";

    let payload = json!({"Name": ""});

    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": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteBlueprint")! 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=AWSGlue.DeleteClassifier");

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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteClassifier"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\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=AWSGlue.DeleteClassifier");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier")
  .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=AWSGlue.DeleteClassifier")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

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=AWSGlue.DeleteClassifier');
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=AWSGlue.DeleteClassifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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=AWSGlue.DeleteClassifier',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  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=AWSGlue.DeleteClassifier');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

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=AWSGlue.DeleteClassifier',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=AWSGlue.DeleteClassifier';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier"]
                                                       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=AWSGlue.DeleteClassifier" 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}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier",
  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' => ''
  ]),
  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=AWSGlue.DeleteClassifier', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier');
$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=AWSGlue.DeleteClassifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteClassifier"

payload = { "Name": "" }
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=AWSGlue.DeleteClassifier"

payload <- "{\n  \"Name\": \"\"\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=AWSGlue.DeleteClassifier")

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}"

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}"
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=AWSGlue.DeleteClassifier";

    let payload = json!({"Name": ""});

    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": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteClassifier")! 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=AWSGlue.DeleteColumnStatisticsForPartition");

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:CatalogId ""
                                                                                                                   :DatabaseName ""
                                                                                                                   :TableName ""
                                                                                                                   :PartitionValues ""
                                                                                                                   :ColumnName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForPartition"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForPartition");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition")
  .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=AWSGlue.DeleteColumnStatisticsForPartition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionValues: '',
  ColumnName: ''
});

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=AWSGlue.DeleteColumnStatisticsForPartition');
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=AWSGlue.DeleteColumnStatisticsForPartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CatalogId: '',
    DatabaseName: '',
    TableName: '',
    PartitionValues: '',
    ColumnName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionValues":"","ColumnName":""}'
};

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=AWSGlue.DeleteColumnStatisticsForPartition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionValues": "",\n  "ColumnName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition")
  .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({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionValues: '',
  ColumnName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    CatalogId: '',
    DatabaseName: '',
    TableName: '',
    PartitionValues: '',
    ColumnName: ''
  },
  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=AWSGlue.DeleteColumnStatisticsForPartition');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  PartitionValues: '',
  ColumnName: ''
});

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=AWSGlue.DeleteColumnStatisticsForPartition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CatalogId: '',
    DatabaseName: '',
    TableName: '',
    PartitionValues: '',
    ColumnName: ''
  }
};

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=AWSGlue.DeleteColumnStatisticsForPartition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","PartitionValues":"","ColumnName":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"PartitionValues": @"",
                              @"ColumnName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition"]
                                                       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=AWSGlue.DeleteColumnStatisticsForPartition" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'PartitionValues' => '',
    'ColumnName' => ''
  ]),
  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=AWSGlue.DeleteColumnStatisticsForPartition', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionValues' => '',
  'ColumnName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'PartitionValues' => '',
  'ColumnName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition');
$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=AWSGlue.DeleteColumnStatisticsForPartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForPartition"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "PartitionValues": "",
    "ColumnName": ""
}
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=AWSGlue.DeleteColumnStatisticsForPartition"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForPartition")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"PartitionValues\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForPartition";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "PartitionValues": "",
        "ColumnName": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "PartitionValues": "",\n  "ColumnName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "PartitionValues": "",
  "ColumnName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForPartition")! 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=AWSGlue.DeleteColumnStatisticsForTable");

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:CatalogId ""
                                                                                                               :DatabaseName ""
                                                                                                               :TableName ""
                                                                                                               :ColumnName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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: 82

{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable")
  .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=AWSGlue.DeleteColumnStatisticsForTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  ColumnName: ''
});

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=AWSGlue.DeleteColumnStatisticsForTable');
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=AWSGlue.DeleteColumnStatisticsForTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', ColumnName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","ColumnName":""}'
};

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=AWSGlue.DeleteColumnStatisticsForTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "ColumnName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable")
  .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({CatalogId: '', DatabaseName: '', TableName: '', ColumnName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', DatabaseName: '', TableName: '', ColumnName: ''},
  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=AWSGlue.DeleteColumnStatisticsForTable');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  DatabaseName: '',
  TableName: '',
  ColumnName: ''
});

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=AWSGlue.DeleteColumnStatisticsForTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', DatabaseName: '', TableName: '', ColumnName: ''}
};

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=AWSGlue.DeleteColumnStatisticsForTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","DatabaseName":"","TableName":"","ColumnName":""}'
};

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 = @{ @"CatalogId": @"",
                              @"DatabaseName": @"",
                              @"TableName": @"",
                              @"ColumnName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable"]
                                                       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=AWSGlue.DeleteColumnStatisticsForTable" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable",
  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([
    'CatalogId' => '',
    'DatabaseName' => '',
    'TableName' => '',
    'ColumnName' => ''
  ]),
  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=AWSGlue.DeleteColumnStatisticsForTable', [
  'body' => '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'ColumnName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'DatabaseName' => '',
  'TableName' => '',
  'ColumnName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable');
$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=AWSGlue.DeleteColumnStatisticsForTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForTable"

payload = {
    "CatalogId": "",
    "DatabaseName": "",
    "TableName": "",
    "ColumnName": ""
}
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=AWSGlue.DeleteColumnStatisticsForTable"

payload <- "{\n  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForTable")

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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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  \"CatalogId\": \"\",\n  \"DatabaseName\": \"\",\n  \"TableName\": \"\",\n  \"ColumnName\": \"\"\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=AWSGlue.DeleteColumnStatisticsForTable";

    let payload = json!({
        "CatalogId": "",
        "DatabaseName": "",
        "TableName": "",
        "ColumnName": ""
    });

    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 '{
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "DatabaseName": "",\n  "TableName": "",\n  "ColumnName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "DatabaseName": "",
  "TableName": "",
  "ColumnName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteColumnStatisticsForTable")! 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=AWSGlue.DeleteConnection");

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  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:CatalogId ""
                                                                                                 :ConnectionName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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=AWSGlue.DeleteConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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=AWSGlue.DeleteConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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: 45

{
  "CatalogId": "",
  "ConnectionName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection")
  .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=AWSGlue.DeleteConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  ConnectionName: ''
});

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=AWSGlue.DeleteConnection');
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=AWSGlue.DeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","ConnectionName":""}'
};

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=AWSGlue.DeleteConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "ConnectionName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection")
  .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({CatalogId: '', ConnectionName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', ConnectionName: ''},
  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=AWSGlue.DeleteConnection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  ConnectionName: ''
});

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=AWSGlue.DeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', ConnectionName: ''}
};

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=AWSGlue.DeleteConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","ConnectionName":""}'
};

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 = @{ @"CatalogId": @"",
                              @"ConnectionName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection"]
                                                       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=AWSGlue.DeleteConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection",
  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([
    'CatalogId' => '',
    'ConnectionName' => ''
  ]),
  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=AWSGlue.DeleteConnection', [
  'body' => '{
  "CatalogId": "",
  "ConnectionName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'ConnectionName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'ConnectionName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection');
$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=AWSGlue.DeleteConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "ConnectionName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "ConnectionName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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=AWSGlue.DeleteConnection"

payload = {
    "CatalogId": "",
    "ConnectionName": ""
}
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=AWSGlue.DeleteConnection"

payload <- "{\n  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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=AWSGlue.DeleteConnection")

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  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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  \"CatalogId\": \"\",\n  \"ConnectionName\": \"\"\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=AWSGlue.DeleteConnection";

    let payload = json!({
        "CatalogId": "",
        "ConnectionName": ""
    });

    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 '{
  "CatalogId": "",
  "ConnectionName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "ConnectionName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "ConnectionName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteConnection")! 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=AWSGlue.DeleteCrawler");

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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler" {:headers {:x-amz-target ""}
                                                                                :content-type :json
                                                                                :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCrawler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\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=AWSGlue.DeleteCrawler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler")
  .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=AWSGlue.DeleteCrawler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

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=AWSGlue.DeleteCrawler');
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=AWSGlue.DeleteCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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=AWSGlue.DeleteCrawler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  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=AWSGlue.DeleteCrawler');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

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=AWSGlue.DeleteCrawler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=AWSGlue.DeleteCrawler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler"]
                                                       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=AWSGlue.DeleteCrawler" 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}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler",
  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' => ''
  ]),
  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=AWSGlue.DeleteCrawler', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler');
$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=AWSGlue.DeleteCrawler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCrawler"

payload = { "Name": "" }
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=AWSGlue.DeleteCrawler"

payload <- "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCrawler")

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}"

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}"
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=AWSGlue.DeleteCrawler";

    let payload = json!({"Name": ""});

    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": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCrawler")! 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=AWSGlue.DeleteCustomEntityType");

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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCustomEntityType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\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=AWSGlue.DeleteCustomEntityType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType")
  .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=AWSGlue.DeleteCustomEntityType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

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=AWSGlue.DeleteCustomEntityType');
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=AWSGlue.DeleteCustomEntityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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=AWSGlue.DeleteCustomEntityType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  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=AWSGlue.DeleteCustomEntityType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

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=AWSGlue.DeleteCustomEntityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=AWSGlue.DeleteCustomEntityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType"]
                                                       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=AWSGlue.DeleteCustomEntityType" 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}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType",
  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' => ''
  ]),
  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=AWSGlue.DeleteCustomEntityType', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType');
$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=AWSGlue.DeleteCustomEntityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCustomEntityType"

payload = { "Name": "" }
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=AWSGlue.DeleteCustomEntityType"

payload <- "{\n  \"Name\": \"\"\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=AWSGlue.DeleteCustomEntityType")

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}"

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}"
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=AWSGlue.DeleteCustomEntityType";

    let payload = json!({"Name": ""});

    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": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteCustomEntityType")! 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=AWSGlue.DeleteDataQualityRuleset");

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}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteDataQualityRuleset"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\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=AWSGlue.DeleteDataQualityRuleset");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset")
  .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=AWSGlue.DeleteDataQualityRuleset")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

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=AWSGlue.DeleteDataQualityRuleset');
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=AWSGlue.DeleteDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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=AWSGlue.DeleteDataQualityRuleset',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  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=AWSGlue.DeleteDataQualityRuleset');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

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=AWSGlue.DeleteDataQualityRuleset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=AWSGlue.DeleteDataQualityRuleset';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset"]
                                                       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=AWSGlue.DeleteDataQualityRuleset" 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}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset",
  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' => ''
  ]),
  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=AWSGlue.DeleteDataQualityRuleset', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset');
$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=AWSGlue.DeleteDataQualityRuleset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=AWSGlue.DeleteDataQualityRuleset"

payload = { "Name": "" }
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=AWSGlue.DeleteDataQualityRuleset"

payload <- "{\n  \"Name\": \"\"\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=AWSGlue.DeleteDataQualityRuleset")

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}"

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}"
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=AWSGlue.DeleteDataQualityRuleset";

    let payload = json!({"Name": ""});

    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": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDataQualityRuleset")! 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=AWSGlue.DeleteDatabase");

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  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:CatalogId ""
                                                                                               :Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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=AWSGlue.DeleteDatabase"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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=AWSGlue.DeleteDatabase");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase"

	payload := strings.NewReader("{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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

{
  "CatalogId": "",
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase")
  .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=AWSGlue.DeleteDatabase")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CatalogId: '',
  Name: ''
});

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=AWSGlue.DeleteDatabase');
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=AWSGlue.DeleteDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","Name":""}'
};

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=AWSGlue.DeleteDatabase',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CatalogId": "",\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase")
  .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({CatalogId: '', Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CatalogId: '', Name: ''},
  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=AWSGlue.DeleteDatabase');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CatalogId: '',
  Name: ''
});

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=AWSGlue.DeleteDatabase',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CatalogId: '', Name: ''}
};

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=AWSGlue.DeleteDatabase';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CatalogId":"","Name":""}'
};

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 = @{ @"CatalogId": @"",
                              @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase"]
                                                       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=AWSGlue.DeleteDatabase" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase",
  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([
    'CatalogId' => '',
    'Name' => ''
  ]),
  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=AWSGlue.DeleteDatabase', [
  'body' => '{
  "CatalogId": "",
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CatalogId' => '',
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CatalogId' => '',
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase');
$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=AWSGlue.DeleteDatabase' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CatalogId": "",
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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=AWSGlue.DeleteDatabase"

payload = {
    "CatalogId": "",
    "Name": ""
}
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=AWSGlue.DeleteDatabase"

payload <- "{\n  \"CatalogId\": \"\",\n  \"Name\": \"\"\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=AWSGlue.DeleteDatabase")

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  \"CatalogId\": \"\",\n  \"Name\": \"\"\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  \"CatalogId\": \"\",\n  \"Name\": \"\"\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=AWSGlue.DeleteDatabase";

    let payload = json!({
        "CatalogId": "",
        "Name": ""
    });

    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 '{
  "CatalogId": "",
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CatalogId": "",\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CatalogId": "",
  "Name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDatabase")! 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=AWSGlue.DeleteDevEndpoint");

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  \"EndpointName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:EndpointName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointName\": \"\"\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=AWSGlue.DeleteDevEndpoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointName\": \"\"\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=AWSGlue.DeleteDevEndpoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint"

	payload := strings.NewReader("{\n  \"EndpointName\": \"\"\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

{
  "EndpointName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointName\": \"\"\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  \"EndpointName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint")
  .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=AWSGlue.DeleteDevEndpoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointName: ''
});

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=AWSGlue.DeleteDevEndpoint');
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=AWSGlue.DeleteDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointName":""}'
};

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=AWSGlue.DeleteDevEndpoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint")
  .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({EndpointName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EndpointName: ''},
  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=AWSGlue.DeleteDevEndpoint');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  EndpointName: ''
});

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=AWSGlue.DeleteDevEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointName: ''}
};

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=AWSGlue.DeleteDevEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointName":""}'
};

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 = @{ @"EndpointName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint"]
                                                       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=AWSGlue.DeleteDevEndpoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint",
  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([
    'EndpointName' => ''
  ]),
  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=AWSGlue.DeleteDevEndpoint', [
  'body' => '{
  "EndpointName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'EndpointName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint');
$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=AWSGlue.DeleteDevEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"EndpointName\": \"\"\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=AWSGlue.DeleteDevEndpoint"

payload = { "EndpointName": "" }
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=AWSGlue.DeleteDevEndpoint"

payload <- "{\n  \"EndpointName\": \"\"\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=AWSGlue.DeleteDevEndpoint")

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  \"EndpointName\": \"\"\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  \"EndpointName\": \"\"\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=AWSGlue.DeleteDevEndpoint";

    let payload = json!({"EndpointName": ""});

    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 '{
  "EndpointName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["EndpointName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteDevEndpoint")! 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=AWSGlue.DeleteJob");

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  \"JobName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob" {:headers {:x-amz-target ""}
                                                                            :content-type :json
                                                                            :form-params {:JobName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"JobName\": \"\"\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=AWSGlue.DeleteJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"JobName\": \"\"\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=AWSGlue.DeleteJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"JobName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob"

	payload := strings.NewReader("{\n  \"JobName\": \"\"\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: 19

{
  "JobName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"JobName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"JobName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob")
  .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=AWSGlue.DeleteJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"JobName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  JobName: ''
});

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=AWSGlue.DeleteJob');
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=AWSGlue.DeleteJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":""}'
};

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=AWSGlue.DeleteJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "JobName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"JobName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob")
  .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({JobName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {JobName: ''},
  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=AWSGlue.DeleteJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  JobName: ''
});

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=AWSGlue.DeleteJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {JobName: ''}
};

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=AWSGlue.DeleteJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"JobName":""}'
};

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 = @{ @"JobName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob"]
                                                       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=AWSGlue.DeleteJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"JobName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'JobName' => ''
  ]),
  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=AWSGlue.DeleteJob', [
  'body' => '{
  "JobName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'JobName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'JobName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob');
$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=AWSGlue.DeleteJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSGlue.DeleteJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "JobName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"JobName\": \"\"\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=AWSGlue.DeleteJob"

payload = { "JobName": "" }
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=AWSGlue.DeleteJob"

payload <- "{\n  \"JobName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")