Amazon DynamoDBv2012-08-10

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchExecuteStatement" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:Statements ""
                                                                                                                :ReturnConsumedCapacity ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchExecuteStatement"

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

{
  "Statements": "",
  "ReturnConsumedCapacity": ""
}

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

client.close();

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

const data = JSON.stringify({
  Statements: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.BatchExecuteStatement');
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=DynamoDB_20120810.BatchExecuteStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Statements: '', ReturnConsumedCapacity: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Statements: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.BatchExecuteStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Statements: '', ReturnConsumedCapacity: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Statements\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchExecuteStatement"

payload = {
    "Statements": "",
    "ReturnConsumedCapacity": ""
}
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=DynamoDB_20120810.BatchExecuteStatement"

payload <- "{\n  \"Statements\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchExecuteStatement")

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  \"Statements\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"Statements\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchExecuteStatement";

    let payload = json!({
        "Statements": "",
        "ReturnConsumedCapacity": ""
    });

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchGetItem" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:RequestItems ""
                                                                                                       :ReturnConsumedCapacity ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchGetItem"

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

{
  "RequestItems": "",
  "ReturnConsumedCapacity": ""
}

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

client.close();

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

const data = JSON.stringify({
  RequestItems: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.BatchGetItem');
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=DynamoDB_20120810.BatchGetItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RequestItems: '', ReturnConsumedCapacity: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  RequestItems: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.BatchGetItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RequestItems: '', ReturnConsumedCapacity: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchGetItem"

payload = {
    "RequestItems": "",
    "ReturnConsumedCapacity": ""
}
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=DynamoDB_20120810.BatchGetItem"

payload <- "{\n  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchGetItem")

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  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.BatchGetItem";

    let payload = json!({
        "RequestItems": "",
        "ReturnConsumedCapacity": ""
    });

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

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

import Foundation

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

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

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

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  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchWriteItem" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:RequestItems ""
                                                                                                         :ReturnConsumedCapacity ""
                                                                                                         :ReturnItemCollectionMetrics ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchWriteItem"

	payload := strings.NewReader("{\n  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\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: 93

{
  "RequestItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": ""
}

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

client.close();

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

const data = JSON.stringify({
  RequestItems: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: ''
});

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=DynamoDB_20120810.BatchWriteItem');
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=DynamoDB_20120810.BatchWriteItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RequestItems: '', ReturnConsumedCapacity: '', ReturnItemCollectionMetrics: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchWriteItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RequestItems":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  RequestItems: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: ''
});

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=DynamoDB_20120810.BatchWriteItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {RequestItems: '', ReturnConsumedCapacity: '', ReturnItemCollectionMetrics: ''}
};

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=DynamoDB_20120810.BatchWriteItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"RequestItems":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":""}'
};

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 = @{ @"RequestItems": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ReturnItemCollectionMetrics": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RequestItems' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\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=DynamoDB_20120810.BatchWriteItem"

payload = {
    "RequestItems": "",
    "ReturnConsumedCapacity": "",
    "ReturnItemCollectionMetrics": ""
}
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=DynamoDB_20120810.BatchWriteItem"

payload <- "{\n  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\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=DynamoDB_20120810.BatchWriteItem")

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  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\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  \"RequestItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\"\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=DynamoDB_20120810.BatchWriteItem";

    let payload = json!({
        "RequestItems": "",
        "ReturnConsumedCapacity": "",
        "ReturnItemCollectionMetrics": ""
    });

    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 '{
  "RequestItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchWriteItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "RequestItems": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.BatchWriteItem'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateBackup" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:TableName ""
                                                                                                       :BackupName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateBackup"

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

{
  "TableName": "",
  "BackupName": ""
}

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

client.close();

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

const data = JSON.stringify({
  TableName: '',
  BackupName: ''
});

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=DynamoDB_20120810.CreateBackup');
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=DynamoDB_20120810.CreateBackup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', BackupName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  TableName: '',
  BackupName: ''
});

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=DynamoDB_20120810.CreateBackup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', BackupName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\",\n  \"BackupName\": \"\"\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=DynamoDB_20120810.CreateBackup"

payload = {
    "TableName": "",
    "BackupName": ""
}
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=DynamoDB_20120810.CreateBackup"

payload <- "{\n  \"TableName\": \"\",\n  \"BackupName\": \"\"\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=DynamoDB_20120810.CreateBackup")

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  \"TableName\": \"\",\n  \"BackupName\": \"\"\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  \"TableName\": \"\",\n  \"BackupName\": \"\"\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=DynamoDB_20120810.CreateBackup";

    let payload = json!({
        "TableName": "",
        "BackupName": ""
    });

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateGlobalTable" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:GlobalTableName ""
                                                                                                            :ReplicationGroup ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateGlobalTable"

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

{
  "GlobalTableName": "",
  "ReplicationGroup": ""
}

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

client.close();

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

const data = JSON.stringify({
  GlobalTableName: '',
  ReplicationGroup: ''
});

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=DynamoDB_20120810.CreateGlobalTable');
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=DynamoDB_20120810.CreateGlobalTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GlobalTableName: '', ReplicationGroup: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  GlobalTableName: '',
  ReplicationGroup: ''
});

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=DynamoDB_20120810.CreateGlobalTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GlobalTableName: '', ReplicationGroup: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"GlobalTableName\": \"\",\n  \"ReplicationGroup\": \"\"\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=DynamoDB_20120810.CreateGlobalTable"

payload = {
    "GlobalTableName": "",
    "ReplicationGroup": ""
}
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=DynamoDB_20120810.CreateGlobalTable"

payload <- "{\n  \"GlobalTableName\": \"\",\n  \"ReplicationGroup\": \"\"\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=DynamoDB_20120810.CreateGlobalTable")

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  \"GlobalTableName\": \"\",\n  \"ReplicationGroup\": \"\"\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  \"GlobalTableName\": \"\",\n  \"ReplicationGroup\": \"\"\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=DynamoDB_20120810.CreateGlobalTable";

    let payload = json!({
        "GlobalTableName": "",
        "ReplicationGroup": ""
    });

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

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateGlobalTable")! 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=DynamoDB_20120810.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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:AttributeDefinitions ""
                                                                                                      :TableName ""
                                                                                                      :KeySchema ""
                                                                                                      :LocalSecondaryIndexes ""
                                                                                                      :GlobalSecondaryIndexes ""
                                                                                                      :BillingMode ""
                                                                                                      :ProvisionedThroughput ""
                                                                                                      :StreamSpecification ""
                                                                                                      :SSESpecification ""
                                                                                                      :Tags ""
                                                                                                      :TableClass ""
                                                                                                      :DeletionProtectionEnabled ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.CreateTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.CreateTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable"

	payload := strings.NewReader("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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: 309

{
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.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=DynamoDB_20120810.CreateTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AttributeDefinitions: '',
  TableName: '',
  KeySchema: '',
  LocalSecondaryIndexes: '',
  GlobalSecondaryIndexes: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  StreamSpecification: '',
  SSESpecification: '',
  Tags: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
});

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=DynamoDB_20120810.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=DynamoDB_20120810.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AttributeDefinitions: '',
    TableName: '',
    KeySchema: '',
    LocalSecondaryIndexes: '',
    GlobalSecondaryIndexes: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    StreamSpecification: '',
    SSESpecification: '',
    Tags: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AttributeDefinitions":"","TableName":"","KeySchema":"","LocalSecondaryIndexes":"","GlobalSecondaryIndexes":"","BillingMode":"","ProvisionedThroughput":"","StreamSpecification":"","SSESpecification":"","Tags":"","TableClass":"","DeletionProtectionEnabled":""}'
};

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=DynamoDB_20120810.CreateTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AttributeDefinitions": "",\n  "TableName": "",\n  "KeySchema": "",\n  "LocalSecondaryIndexes": "",\n  "GlobalSecondaryIndexes": "",\n  "BillingMode": "",\n  "ProvisionedThroughput": "",\n  "StreamSpecification": "",\n  "SSESpecification": "",\n  "Tags": "",\n  "TableClass": "",\n  "DeletionProtectionEnabled": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.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({
  AttributeDefinitions: '',
  TableName: '',
  KeySchema: '',
  LocalSecondaryIndexes: '',
  GlobalSecondaryIndexes: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  StreamSpecification: '',
  SSESpecification: '',
  Tags: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AttributeDefinitions: '',
    TableName: '',
    KeySchema: '',
    LocalSecondaryIndexes: '',
    GlobalSecondaryIndexes: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    StreamSpecification: '',
    SSESpecification: '',
    Tags: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  },
  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=DynamoDB_20120810.CreateTable');

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

req.type('json');
req.send({
  AttributeDefinitions: '',
  TableName: '',
  KeySchema: '',
  LocalSecondaryIndexes: '',
  GlobalSecondaryIndexes: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  StreamSpecification: '',
  SSESpecification: '',
  Tags: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
});

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=DynamoDB_20120810.CreateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AttributeDefinitions: '',
    TableName: '',
    KeySchema: '',
    LocalSecondaryIndexes: '',
    GlobalSecondaryIndexes: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    StreamSpecification: '',
    SSESpecification: '',
    Tags: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  }
};

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=DynamoDB_20120810.CreateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AttributeDefinitions":"","TableName":"","KeySchema":"","LocalSecondaryIndexes":"","GlobalSecondaryIndexes":"","BillingMode":"","ProvisionedThroughput":"","StreamSpecification":"","SSESpecification":"","Tags":"","TableClass":"","DeletionProtectionEnabled":""}'
};

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 = @{ @"AttributeDefinitions": @"",
                              @"TableName": @"",
                              @"KeySchema": @"",
                              @"LocalSecondaryIndexes": @"",
                              @"GlobalSecondaryIndexes": @"",
                              @"BillingMode": @"",
                              @"ProvisionedThroughput": @"",
                              @"StreamSpecification": @"",
                              @"SSESpecification": @"",
                              @"Tags": @"",
                              @"TableClass": @"",
                              @"DeletionProtectionEnabled": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.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=DynamoDB_20120810.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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.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([
    'AttributeDefinitions' => '',
    'TableName' => '',
    'KeySchema' => '',
    'LocalSecondaryIndexes' => '',
    'GlobalSecondaryIndexes' => '',
    'BillingMode' => '',
    'ProvisionedThroughput' => '',
    'StreamSpecification' => '',
    'SSESpecification' => '',
    'Tags' => '',
    'TableClass' => '',
    'DeletionProtectionEnabled' => ''
  ]),
  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=DynamoDB_20120810.CreateTable', [
  'body' => '{
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AttributeDefinitions' => '',
  'TableName' => '',
  'KeySchema' => '',
  'LocalSecondaryIndexes' => '',
  'GlobalSecondaryIndexes' => '',
  'BillingMode' => '',
  'ProvisionedThroughput' => '',
  'StreamSpecification' => '',
  'SSESpecification' => '',
  'Tags' => '',
  'TableClass' => '',
  'DeletionProtectionEnabled' => ''
]));

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

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

append(json_encode([
  'AttributeDefinitions' => '',
  'TableName' => '',
  'KeySchema' => '',
  'LocalSecondaryIndexes' => '',
  'GlobalSecondaryIndexes' => '',
  'BillingMode' => '',
  'ProvisionedThroughput' => '',
  'StreamSpecification' => '',
  'SSESpecification' => '',
  'Tags' => '',
  'TableClass' => '',
  'DeletionProtectionEnabled' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.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=DynamoDB_20120810.CreateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}'

import http.client

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

payload = "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.CreateTable"

payload = {
    "AttributeDefinitions": "",
    "TableName": "",
    "KeySchema": "",
    "LocalSecondaryIndexes": "",
    "GlobalSecondaryIndexes": "",
    "BillingMode": "",
    "ProvisionedThroughput": "",
    "StreamSpecification": "",
    "SSESpecification": "",
    "Tags": "",
    "TableClass": "",
    "DeletionProtectionEnabled": ""
}
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=DynamoDB_20120810.CreateTable"

payload <- "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"KeySchema\": \"\",\n  \"LocalSecondaryIndexes\": \"\",\n  \"GlobalSecondaryIndexes\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"Tags\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.CreateTable";

    let payload = json!({
        "AttributeDefinitions": "",
        "TableName": "",
        "KeySchema": "",
        "LocalSecondaryIndexes": "",
        "GlobalSecondaryIndexes": "",
        "BillingMode": "",
        "ProvisionedThroughput": "",
        "StreamSpecification": "",
        "SSESpecification": "",
        "Tags": "",
        "TableClass": "",
        "DeletionProtectionEnabled": ""
    });

    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 '{
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AttributeDefinitions": "",\n  "TableName": "",\n  "KeySchema": "",\n  "LocalSecondaryIndexes": "",\n  "GlobalSecondaryIndexes": "",\n  "BillingMode": "",\n  "ProvisionedThroughput": "",\n  "StreamSpecification": "",\n  "SSESpecification": "",\n  "Tags": "",\n  "TableClass": "",\n  "DeletionProtectionEnabled": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.CreateTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AttributeDefinitions": "",
  "TableName": "",
  "KeySchema": "",
  "LocalSecondaryIndexes": "",
  "GlobalSecondaryIndexes": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "Tags": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteBackup"

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

{
  "BackupArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"BackupArn\": \"\"\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=DynamoDB_20120810.DeleteBackup"

payload = { "BackupArn": "" }
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=DynamoDB_20120810.DeleteBackup"

payload <- "{\n  \"BackupArn\": \"\"\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=DynamoDB_20120810.DeleteBackup")

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  \"BackupArn\": \"\"\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  \"BackupArn\": \"\"\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=DynamoDB_20120810.DeleteBackup";

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

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

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

import Foundation

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

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

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

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:TableName ""
                                                                                                     :Key ""
                                                                                                     :Expected ""
                                                                                                     :ConditionalOperator ""
                                                                                                     :ReturnValues ""
                                                                                                     :ReturnConsumedCapacity ""
                                                                                                     :ReturnItemCollectionMetrics ""
                                                                                                     :ConditionExpression ""
                                                                                                     :ExpressionAttributeNames ""
                                                                                                     :ExpressionAttributeValues ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.DeleteItem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.DeleteItem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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: 270

{
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem")
  .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=DynamoDB_20120810.DeleteItem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  Key: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.DeleteItem');
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=DynamoDB_20120810.DeleteItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","Expected":"","ConditionalOperator":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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=DynamoDB_20120810.DeleteItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "Key": "",\n  "Expected": "",\n  "ConditionalOperator": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem")
  .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({
  TableName: '',
  Key: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    Key: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  },
  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=DynamoDB_20120810.DeleteItem');

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

req.type('json');
req.send({
  TableName: '',
  Key: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.DeleteItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

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=DynamoDB_20120810.DeleteItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","Expected":"","ConditionalOperator":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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 = @{ @"TableName": @"",
                              @"Key": @"",
                              @"Expected": @"",
                              @"ConditionalOperator": @"",
                              @"ReturnValues": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ReturnItemCollectionMetrics": @"",
                              @"ConditionExpression": @"",
                              @"ExpressionAttributeNames": @"",
                              @"ExpressionAttributeValues": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem"]
                                                       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=DynamoDB_20120810.DeleteItem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem",
  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([
    'TableName' => '',
    'Key' => '',
    'Expected' => '',
    'ConditionalOperator' => '',
    'ReturnValues' => '',
    'ReturnConsumedCapacity' => '',
    'ReturnItemCollectionMetrics' => '',
    'ConditionExpression' => '',
    'ExpressionAttributeNames' => '',
    'ExpressionAttributeValues' => ''
  ]),
  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=DynamoDB_20120810.DeleteItem', [
  'body' => '{
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'Key' => '',
  'Expected' => '',
  'ConditionalOperator' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));

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

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

append(json_encode([
  'TableName' => '',
  'Key' => '',
  'Expected' => '',
  'ConditionalOperator' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem');
$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=DynamoDB_20120810.DeleteItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

import http.client

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

payload = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.DeleteItem"

payload = {
    "TableName": "",
    "Key": "",
    "Expected": "",
    "ConditionalOperator": "",
    "ReturnValues": "",
    "ReturnConsumedCapacity": "",
    "ReturnItemCollectionMetrics": "",
    "ConditionExpression": "",
    "ExpressionAttributeNames": "",
    "ExpressionAttributeValues": ""
}
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=DynamoDB_20120810.DeleteItem"

payload <- "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.DeleteItem")

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.DeleteItem";

    let payload = json!({
        "TableName": "",
        "Key": "",
        "Expected": "",
        "ConditionalOperator": "",
        "ReturnValues": "",
        "ReturnConsumedCapacity": "",
        "ReturnItemCollectionMetrics": "",
        "ConditionExpression": "",
        "ExpressionAttributeNames": "",
        "ExpressionAttributeValues": ""
    });

    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 '{
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "Key": "",\n  "Expected": "",\n  "ConditionalOperator": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteItem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "Key": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DeleteTable"

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

{
  "TableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DeleteTable"

payload = { "TableName": "" }
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=DynamoDB_20120810.DeleteTable"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DeleteTable")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DeleteTable";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeBackup"

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

{
  "BackupArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"BackupArn\": \"\"\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=DynamoDB_20120810.DescribeBackup"

payload = { "BackupArn": "" }
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=DynamoDB_20120810.DescribeBackup"

payload <- "{\n  \"BackupArn\": \"\"\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=DynamoDB_20120810.DescribeBackup")

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  \"BackupArn\": \"\"\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  \"BackupArn\": \"\"\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=DynamoDB_20120810.DescribeBackup";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeContinuousBackups"

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

{
  "TableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeContinuousBackups"

payload = { "TableName": "" }
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=DynamoDB_20120810.DescribeContinuousBackups"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeContinuousBackups")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeContinuousBackups";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeContributorInsights" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:TableName ""
                                                                                                                      :IndexName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeContributorInsights"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "TableName": "",
  "IndexName": ""
}

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

client.close();

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

const data = JSON.stringify({
  TableName: '',
  IndexName: ''
});

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=DynamoDB_20120810.DescribeContributorInsights');
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=DynamoDB_20120810.DescribeContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', IndexName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  TableName: '',
  IndexName: ''
});

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=DynamoDB_20120810.DescribeContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', IndexName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\"\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=DynamoDB_20120810.DescribeContributorInsights"

payload = {
    "TableName": "",
    "IndexName": ""
}
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=DynamoDB_20120810.DescribeContributorInsights"

payload <- "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\"\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=DynamoDB_20120810.DescribeContributorInsights")

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  \"TableName\": \"\",\n  \"IndexName\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\"\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=DynamoDB_20120810.DescribeContributorInsights";

    let payload = json!({
        "TableName": "",
        "IndexName": ""
    });

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

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

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints" {:headers {:x-amz-target ""}
                                                                                              :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints');
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=DynamoDB_20120810.DescribeEndpoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints');

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeEndpoints' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeExport"

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

{
  "ExportArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ExportArn\": \"\"\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=DynamoDB_20120810.DescribeExport"

payload = { "ExportArn": "" }
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=DynamoDB_20120810.DescribeExport"

payload <- "{\n  \"ExportArn\": \"\"\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=DynamoDB_20120810.DescribeExport")

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  \"ExportArn\": \"\"\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  \"ExportArn\": \"\"\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=DynamoDB_20120810.DescribeExport";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeGlobalTable"

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

{
  "GlobalTableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTable"

payload = { "GlobalTableName": "" }
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=DynamoDB_20120810.DescribeGlobalTable"

payload <- "{\n  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTable")

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  \"GlobalTableName\": \"\"\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  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTable";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeGlobalTableSettings"

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

{
  "GlobalTableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTableSettings"

payload = { "GlobalTableName": "" }
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=DynamoDB_20120810.DescribeGlobalTableSettings"

payload <- "{\n  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTableSettings")

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  \"GlobalTableName\": \"\"\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  \"GlobalTableName\": \"\"\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=DynamoDB_20120810.DescribeGlobalTableSettings";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeImport"

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

{
  "ImportArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ImportArn\": \"\"\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=DynamoDB_20120810.DescribeImport"

payload = { "ImportArn": "" }
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=DynamoDB_20120810.DescribeImport"

payload <- "{\n  \"ImportArn\": \"\"\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=DynamoDB_20120810.DescribeImport")

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  \"ImportArn\": \"\"\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  \"ImportArn\": \"\"\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=DynamoDB_20120810.DescribeImport";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeKinesisStreamingDestination"

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

{
  "TableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeKinesisStreamingDestination"

payload = { "TableName": "" }
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=DynamoDB_20120810.DescribeKinesisStreamingDestination"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeKinesisStreamingDestination")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeKinesisStreamingDestination";

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

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

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

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits" {:headers {:x-amz-target ""}
                                                                                           :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits"

	payload := strings.NewReader("{}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits');
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=DynamoDB_20120810.DescribeLimits',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits');

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits"

payload <- "{}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({});

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

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

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

    dbg!(results);
}

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeLimits' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTable"

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

{
  "TableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTable"

payload = { "TableName": "" }
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=DynamoDB_20120810.DescribeTable"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTable")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTable";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTableReplicaAutoScaling"

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

{
  "TableName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTableReplicaAutoScaling"

payload = { "TableName": "" }
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=DynamoDB_20120810.DescribeTableReplicaAutoScaling"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTableReplicaAutoScaling")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTableReplicaAutoScaling";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive"

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

{
  "TableName": ""
}

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

client.close();

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

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

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=DynamoDB_20120810.DescribeTimeToLive');
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=DynamoDB_20120810.DescribeTimeToLive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":""}'
};

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=DynamoDB_20120810.DescribeTimeToLive',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive")
  .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({TableName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: ''},
  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=DynamoDB_20120810.DescribeTimeToLive');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: ''
});

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=DynamoDB_20120810.DescribeTimeToLive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: ''}
};

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=DynamoDB_20120810.DescribeTimeToLive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":""}'
};

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 = @{ @"TableName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive"]
                                                       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=DynamoDB_20120810.DescribeTimeToLive" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive",
  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([
    'TableName' => ''
  ]),
  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=DynamoDB_20120810.DescribeTimeToLive', [
  'body' => '{
  "TableName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive');
$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=DynamoDB_20120810.DescribeTimeToLive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTimeToLive"

payload = { "TableName": "" }
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=DynamoDB_20120810.DescribeTimeToLive"

payload <- "{\n  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTimeToLive")

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  \"TableName\": \"\"\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  \"TableName\": \"\"\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=DynamoDB_20120810.DescribeTimeToLive";

    let payload = json!({"TableName": ""});

    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 '{
  "TableName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["TableName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DescribeTimeToLive")! 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=DynamoDB_20120810.DisableKinesisStreamingDestination");

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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:TableName ""
                                                                                                                             :StreamArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.DisableKinesisStreamingDestination"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.DisableKinesisStreamingDestination");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "TableName": "",
  "StreamArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination")
  .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=DynamoDB_20120810.DisableKinesisStreamingDestination")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  StreamArn: ''
});

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=DynamoDB_20120810.DisableKinesisStreamingDestination');
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=DynamoDB_20120810.DisableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', StreamArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","StreamArn":""}'
};

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=DynamoDB_20120810.DisableKinesisStreamingDestination',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "StreamArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination")
  .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({TableName: '', StreamArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: '', StreamArn: ''},
  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=DynamoDB_20120810.DisableKinesisStreamingDestination');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  StreamArn: ''
});

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=DynamoDB_20120810.DisableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', StreamArn: ''}
};

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=DynamoDB_20120810.DisableKinesisStreamingDestination';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","StreamArn":""}'
};

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 = @{ @"TableName": @"",
                              @"StreamArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination"]
                                                       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=DynamoDB_20120810.DisableKinesisStreamingDestination" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination",
  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([
    'TableName' => '',
    'StreamArn' => ''
  ]),
  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=DynamoDB_20120810.DisableKinesisStreamingDestination', [
  'body' => '{
  "TableName": "",
  "StreamArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'StreamArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'StreamArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination');
$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=DynamoDB_20120810.DisableKinesisStreamingDestination' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "StreamArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "StreamArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.DisableKinesisStreamingDestination"

payload = {
    "TableName": "",
    "StreamArn": ""
}
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=DynamoDB_20120810.DisableKinesisStreamingDestination"

payload <- "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.DisableKinesisStreamingDestination")

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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.DisableKinesisStreamingDestination";

    let payload = json!({
        "TableName": "",
        "StreamArn": ""
    });

    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 '{
  "TableName": "",
  "StreamArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "StreamArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "StreamArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.DisableKinesisStreamingDestination")! 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=DynamoDB_20120810.EnableKinesisStreamingDestination");

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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:TableName ""
                                                                                                                            :StreamArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.EnableKinesisStreamingDestination"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.EnableKinesisStreamingDestination");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "TableName": "",
  "StreamArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination")
  .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=DynamoDB_20120810.EnableKinesisStreamingDestination")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  StreamArn: ''
});

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=DynamoDB_20120810.EnableKinesisStreamingDestination');
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=DynamoDB_20120810.EnableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', StreamArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","StreamArn":""}'
};

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=DynamoDB_20120810.EnableKinesisStreamingDestination',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "StreamArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination")
  .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({TableName: '', StreamArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: '', StreamArn: ''},
  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=DynamoDB_20120810.EnableKinesisStreamingDestination');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  StreamArn: ''
});

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=DynamoDB_20120810.EnableKinesisStreamingDestination',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', StreamArn: ''}
};

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=DynamoDB_20120810.EnableKinesisStreamingDestination';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","StreamArn":""}'
};

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 = @{ @"TableName": @"",
                              @"StreamArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination"]
                                                       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=DynamoDB_20120810.EnableKinesisStreamingDestination" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination",
  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([
    'TableName' => '',
    'StreamArn' => ''
  ]),
  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=DynamoDB_20120810.EnableKinesisStreamingDestination', [
  'body' => '{
  "TableName": "",
  "StreamArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'StreamArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'StreamArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination');
$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=DynamoDB_20120810.EnableKinesisStreamingDestination' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "StreamArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "StreamArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.EnableKinesisStreamingDestination"

payload = {
    "TableName": "",
    "StreamArn": ""
}
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=DynamoDB_20120810.EnableKinesisStreamingDestination"

payload <- "{\n  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.EnableKinesisStreamingDestination")

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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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  \"TableName\": \"\",\n  \"StreamArn\": \"\"\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=DynamoDB_20120810.EnableKinesisStreamingDestination";

    let payload = json!({
        "TableName": "",
        "StreamArn": ""
    });

    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 '{
  "TableName": "",
  "StreamArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "StreamArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "StreamArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.EnableKinesisStreamingDestination")! 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=DynamoDB_20120810.ExecuteStatement");

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  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:Statement ""
                                                                                                           :Parameters ""
                                                                                                           :ConsistentRead ""
                                                                                                           :NextToken ""
                                                                                                           :ReturnConsumedCapacity ""
                                                                                                           :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ExecuteStatement"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ExecuteStatement");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement"

	payload := strings.NewReader("{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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: 131

{
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement")
  .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=DynamoDB_20120810.ExecuteStatement")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Statement: '',
  Parameters: '',
  ConsistentRead: '',
  NextToken: '',
  ReturnConsumedCapacity: '',
  Limit: ''
});

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=DynamoDB_20120810.ExecuteStatement');
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=DynamoDB_20120810.ExecuteStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Statement: '',
    Parameters: '',
    ConsistentRead: '',
    NextToken: '',
    ReturnConsumedCapacity: '',
    Limit: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Statement":"","Parameters":"","ConsistentRead":"","NextToken":"","ReturnConsumedCapacity":"","Limit":""}'
};

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=DynamoDB_20120810.ExecuteStatement',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Statement": "",\n  "Parameters": "",\n  "ConsistentRead": "",\n  "NextToken": "",\n  "ReturnConsumedCapacity": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement")
  .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({
  Statement: '',
  Parameters: '',
  ConsistentRead: '',
  NextToken: '',
  ReturnConsumedCapacity: '',
  Limit: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Statement: '',
    Parameters: '',
    ConsistentRead: '',
    NextToken: '',
    ReturnConsumedCapacity: '',
    Limit: ''
  },
  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=DynamoDB_20120810.ExecuteStatement');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Statement: '',
  Parameters: '',
  ConsistentRead: '',
  NextToken: '',
  ReturnConsumedCapacity: '',
  Limit: ''
});

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=DynamoDB_20120810.ExecuteStatement',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Statement: '',
    Parameters: '',
    ConsistentRead: '',
    NextToken: '',
    ReturnConsumedCapacity: '',
    Limit: ''
  }
};

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=DynamoDB_20120810.ExecuteStatement';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Statement":"","Parameters":"","ConsistentRead":"","NextToken":"","ReturnConsumedCapacity":"","Limit":""}'
};

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 = @{ @"Statement": @"",
                              @"Parameters": @"",
                              @"ConsistentRead": @"",
                              @"NextToken": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement"]
                                                       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=DynamoDB_20120810.ExecuteStatement" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement",
  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([
    'Statement' => '',
    'Parameters' => '',
    'ConsistentRead' => '',
    'NextToken' => '',
    'ReturnConsumedCapacity' => '',
    'Limit' => ''
  ]),
  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=DynamoDB_20120810.ExecuteStatement', [
  'body' => '{
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Statement' => '',
  'Parameters' => '',
  'ConsistentRead' => '',
  'NextToken' => '',
  'ReturnConsumedCapacity' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Statement' => '',
  'Parameters' => '',
  'ConsistentRead' => '',
  'NextToken' => '',
  'ReturnConsumedCapacity' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement');
$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=DynamoDB_20120810.ExecuteStatement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ExecuteStatement"

payload = {
    "Statement": "",
    "Parameters": "",
    "ConsistentRead": "",
    "NextToken": "",
    "ReturnConsumedCapacity": "",
    "Limit": ""
}
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=DynamoDB_20120810.ExecuteStatement"

payload <- "{\n  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ExecuteStatement")

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  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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  \"Statement\": \"\",\n  \"Parameters\": \"\",\n  \"ConsistentRead\": \"\",\n  \"NextToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ExecuteStatement";

    let payload = json!({
        "Statement": "",
        "Parameters": "",
        "ConsistentRead": "",
        "NextToken": "",
        "ReturnConsumedCapacity": "",
        "Limit": ""
    });

    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 '{
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Statement": "",\n  "Parameters": "",\n  "ConsistentRead": "",\n  "NextToken": "",\n  "ReturnConsumedCapacity": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Statement": "",
  "Parameters": "",
  "ConsistentRead": "",
  "NextToken": "",
  "ReturnConsumedCapacity": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteStatement")! 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=DynamoDB_20120810.ExecuteTransaction");

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  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:TransactStatements ""
                                                                                                             :ClientRequestToken ""
                                                                                                             :ReturnConsumedCapacity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.ExecuteTransaction"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.ExecuteTransaction");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction"

	payload := strings.NewReader("{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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

{
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction")
  .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=DynamoDB_20120810.ExecuteTransaction")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TransactStatements: '',
  ClientRequestToken: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.ExecuteTransaction');
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=DynamoDB_20120810.ExecuteTransaction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransactStatements: '', ClientRequestToken: '', ReturnConsumedCapacity: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactStatements":"","ClientRequestToken":"","ReturnConsumedCapacity":""}'
};

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=DynamoDB_20120810.ExecuteTransaction',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransactStatements": "",\n  "ClientRequestToken": "",\n  "ReturnConsumedCapacity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction")
  .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({TransactStatements: '', ClientRequestToken: '', ReturnConsumedCapacity: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TransactStatements: '', ClientRequestToken: '', ReturnConsumedCapacity: ''},
  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=DynamoDB_20120810.ExecuteTransaction');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TransactStatements: '',
  ClientRequestToken: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.ExecuteTransaction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransactStatements: '', ClientRequestToken: '', ReturnConsumedCapacity: ''}
};

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=DynamoDB_20120810.ExecuteTransaction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactStatements":"","ClientRequestToken":"","ReturnConsumedCapacity":""}'
};

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 = @{ @"TransactStatements": @"",
                              @"ClientRequestToken": @"",
                              @"ReturnConsumedCapacity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction"]
                                                       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=DynamoDB_20120810.ExecuteTransaction" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction",
  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([
    'TransactStatements' => '',
    'ClientRequestToken' => '',
    'ReturnConsumedCapacity' => ''
  ]),
  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=DynamoDB_20120810.ExecuteTransaction', [
  'body' => '{
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransactStatements' => '',
  'ClientRequestToken' => '',
  'ReturnConsumedCapacity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TransactStatements' => '',
  'ClientRequestToken' => '',
  'ReturnConsumedCapacity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction');
$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=DynamoDB_20120810.ExecuteTransaction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.ExecuteTransaction"

payload = {
    "TransactStatements": "",
    "ClientRequestToken": "",
    "ReturnConsumedCapacity": ""
}
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=DynamoDB_20120810.ExecuteTransaction"

payload <- "{\n  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.ExecuteTransaction")

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  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"TransactStatements\": \"\",\n  \"ClientRequestToken\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.ExecuteTransaction";

    let payload = json!({
        "TransactStatements": "",
        "ClientRequestToken": "",
        "ReturnConsumedCapacity": ""
    });

    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 '{
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TransactStatements": "",\n  "ClientRequestToken": "",\n  "ReturnConsumedCapacity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TransactStatements": "",
  "ClientRequestToken": "",
  "ReturnConsumedCapacity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExecuteTransaction")! 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=DynamoDB_20120810.ExportTableToPointInTime");

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  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:TableArn ""
                                                                                                                   :ExportTime ""
                                                                                                                   :ClientToken ""
                                                                                                                   :S3Bucket ""
                                                                                                                   :S3BucketOwner ""
                                                                                                                   :S3Prefix ""
                                                                                                                   :S3SseAlgorithm ""
                                                                                                                   :S3SseKmsKeyId ""
                                                                                                                   :ExportFormat ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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=DynamoDB_20120810.ExportTableToPointInTime"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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=DynamoDB_20120810.ExportTableToPointInTime");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime"

	payload := strings.NewReader("{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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: 189

{
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime")
  .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=DynamoDB_20120810.ExportTableToPointInTime")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableArn: '',
  ExportTime: '',
  ClientToken: '',
  S3Bucket: '',
  S3BucketOwner: '',
  S3Prefix: '',
  S3SseAlgorithm: '',
  S3SseKmsKeyId: '',
  ExportFormat: ''
});

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=DynamoDB_20120810.ExportTableToPointInTime');
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=DynamoDB_20120810.ExportTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableArn: '',
    ExportTime: '',
    ClientToken: '',
    S3Bucket: '',
    S3BucketOwner: '',
    S3Prefix: '',
    S3SseAlgorithm: '',
    S3SseKmsKeyId: '',
    ExportFormat: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","ExportTime":"","ClientToken":"","S3Bucket":"","S3BucketOwner":"","S3Prefix":"","S3SseAlgorithm":"","S3SseKmsKeyId":"","ExportFormat":""}'
};

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=DynamoDB_20120810.ExportTableToPointInTime',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableArn": "",\n  "ExportTime": "",\n  "ClientToken": "",\n  "S3Bucket": "",\n  "S3BucketOwner": "",\n  "S3Prefix": "",\n  "S3SseAlgorithm": "",\n  "S3SseKmsKeyId": "",\n  "ExportFormat": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime")
  .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({
  TableArn: '',
  ExportTime: '',
  ClientToken: '',
  S3Bucket: '',
  S3BucketOwner: '',
  S3Prefix: '',
  S3SseAlgorithm: '',
  S3SseKmsKeyId: '',
  ExportFormat: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableArn: '',
    ExportTime: '',
    ClientToken: '',
    S3Bucket: '',
    S3BucketOwner: '',
    S3Prefix: '',
    S3SseAlgorithm: '',
    S3SseKmsKeyId: '',
    ExportFormat: ''
  },
  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=DynamoDB_20120810.ExportTableToPointInTime');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableArn: '',
  ExportTime: '',
  ClientToken: '',
  S3Bucket: '',
  S3BucketOwner: '',
  S3Prefix: '',
  S3SseAlgorithm: '',
  S3SseKmsKeyId: '',
  ExportFormat: ''
});

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=DynamoDB_20120810.ExportTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableArn: '',
    ExportTime: '',
    ClientToken: '',
    S3Bucket: '',
    S3BucketOwner: '',
    S3Prefix: '',
    S3SseAlgorithm: '',
    S3SseKmsKeyId: '',
    ExportFormat: ''
  }
};

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=DynamoDB_20120810.ExportTableToPointInTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","ExportTime":"","ClientToken":"","S3Bucket":"","S3BucketOwner":"","S3Prefix":"","S3SseAlgorithm":"","S3SseKmsKeyId":"","ExportFormat":""}'
};

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 = @{ @"TableArn": @"",
                              @"ExportTime": @"",
                              @"ClientToken": @"",
                              @"S3Bucket": @"",
                              @"S3BucketOwner": @"",
                              @"S3Prefix": @"",
                              @"S3SseAlgorithm": @"",
                              @"S3SseKmsKeyId": @"",
                              @"ExportFormat": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime"]
                                                       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=DynamoDB_20120810.ExportTableToPointInTime" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime",
  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([
    'TableArn' => '',
    'ExportTime' => '',
    'ClientToken' => '',
    'S3Bucket' => '',
    'S3BucketOwner' => '',
    'S3Prefix' => '',
    'S3SseAlgorithm' => '',
    'S3SseKmsKeyId' => '',
    'ExportFormat' => ''
  ]),
  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=DynamoDB_20120810.ExportTableToPointInTime', [
  'body' => '{
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableArn' => '',
  'ExportTime' => '',
  'ClientToken' => '',
  'S3Bucket' => '',
  'S3BucketOwner' => '',
  'S3Prefix' => '',
  'S3SseAlgorithm' => '',
  'S3SseKmsKeyId' => '',
  'ExportFormat' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableArn' => '',
  'ExportTime' => '',
  'ClientToken' => '',
  'S3Bucket' => '',
  'S3BucketOwner' => '',
  'S3Prefix' => '',
  'S3SseAlgorithm' => '',
  'S3SseKmsKeyId' => '',
  'ExportFormat' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime');
$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=DynamoDB_20120810.ExportTableToPointInTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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=DynamoDB_20120810.ExportTableToPointInTime"

payload = {
    "TableArn": "",
    "ExportTime": "",
    "ClientToken": "",
    "S3Bucket": "",
    "S3BucketOwner": "",
    "S3Prefix": "",
    "S3SseAlgorithm": "",
    "S3SseKmsKeyId": "",
    "ExportFormat": ""
}
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=DynamoDB_20120810.ExportTableToPointInTime"

payload <- "{\n  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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=DynamoDB_20120810.ExportTableToPointInTime")

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  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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  \"TableArn\": \"\",\n  \"ExportTime\": \"\",\n  \"ClientToken\": \"\",\n  \"S3Bucket\": \"\",\n  \"S3BucketOwner\": \"\",\n  \"S3Prefix\": \"\",\n  \"S3SseAlgorithm\": \"\",\n  \"S3SseKmsKeyId\": \"\",\n  \"ExportFormat\": \"\"\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=DynamoDB_20120810.ExportTableToPointInTime";

    let payload = json!({
        "TableArn": "",
        "ExportTime": "",
        "ClientToken": "",
        "S3Bucket": "",
        "S3BucketOwner": "",
        "S3Prefix": "",
        "S3SseAlgorithm": "",
        "S3SseKmsKeyId": "",
        "ExportFormat": ""
    });

    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 '{
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableArn": "",\n  "ExportTime": "",\n  "ClientToken": "",\n  "S3Bucket": "",\n  "S3BucketOwner": "",\n  "S3Prefix": "",\n  "S3SseAlgorithm": "",\n  "S3SseKmsKeyId": "",\n  "ExportFormat": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableArn": "",
  "ExportTime": "",
  "ClientToken": "",
  "S3Bucket": "",
  "S3BucketOwner": "",
  "S3Prefix": "",
  "S3SseAlgorithm": "",
  "S3SseKmsKeyId": "",
  "ExportFormat": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ExportTableToPointInTime")! 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=DynamoDB_20120810.GetItem");

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:TableName ""
                                                                                                  :Key ""
                                                                                                  :AttributesToGet ""
                                                                                                  :ConsistentRead ""
                                                                                                  :ReturnConsumedCapacity ""
                                                                                                  :ProjectionExpression ""
                                                                                                  :ExpressionAttributeNames ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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=DynamoDB_20120810.GetItem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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=DynamoDB_20120810.GetItem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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: 179

{
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem")
  .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=DynamoDB_20120810.GetItem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  Key: '',
  AttributesToGet: '',
  ConsistentRead: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  ExpressionAttributeNames: ''
});

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=DynamoDB_20120810.GetItem');
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=DynamoDB_20120810.GetItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    AttributesToGet: '',
    ConsistentRead: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    ExpressionAttributeNames: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","AttributesToGet":"","ConsistentRead":"","ReturnConsumedCapacity":"","ProjectionExpression":"","ExpressionAttributeNames":""}'
};

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=DynamoDB_20120810.GetItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "Key": "",\n  "AttributesToGet": "",\n  "ConsistentRead": "",\n  "ReturnConsumedCapacity": "",\n  "ProjectionExpression": "",\n  "ExpressionAttributeNames": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem")
  .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({
  TableName: '',
  Key: '',
  AttributesToGet: '',
  ConsistentRead: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  ExpressionAttributeNames: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    Key: '',
    AttributesToGet: '',
    ConsistentRead: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    ExpressionAttributeNames: ''
  },
  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=DynamoDB_20120810.GetItem');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  Key: '',
  AttributesToGet: '',
  ConsistentRead: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  ExpressionAttributeNames: ''
});

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=DynamoDB_20120810.GetItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    AttributesToGet: '',
    ConsistentRead: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    ExpressionAttributeNames: ''
  }
};

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=DynamoDB_20120810.GetItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","AttributesToGet":"","ConsistentRead":"","ReturnConsumedCapacity":"","ProjectionExpression":"","ExpressionAttributeNames":""}'
};

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 = @{ @"TableName": @"",
                              @"Key": @"",
                              @"AttributesToGet": @"",
                              @"ConsistentRead": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ProjectionExpression": @"",
                              @"ExpressionAttributeNames": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem"]
                                                       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=DynamoDB_20120810.GetItem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem",
  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([
    'TableName' => '',
    'Key' => '',
    'AttributesToGet' => '',
    'ConsistentRead' => '',
    'ReturnConsumedCapacity' => '',
    'ProjectionExpression' => '',
    'ExpressionAttributeNames' => ''
  ]),
  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=DynamoDB_20120810.GetItem', [
  'body' => '{
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'Key' => '',
  'AttributesToGet' => '',
  'ConsistentRead' => '',
  'ReturnConsumedCapacity' => '',
  'ProjectionExpression' => '',
  'ExpressionAttributeNames' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'Key' => '',
  'AttributesToGet' => '',
  'ConsistentRead' => '',
  'ReturnConsumedCapacity' => '',
  'ProjectionExpression' => '',
  'ExpressionAttributeNames' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem');
$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=DynamoDB_20120810.GetItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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=DynamoDB_20120810.GetItem"

payload = {
    "TableName": "",
    "Key": "",
    "AttributesToGet": "",
    "ConsistentRead": "",
    "ReturnConsumedCapacity": "",
    "ProjectionExpression": "",
    "ExpressionAttributeNames": ""
}
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=DynamoDB_20120810.GetItem"

payload <- "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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=DynamoDB_20120810.GetItem")

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributesToGet\": \"\",\n  \"ConsistentRead\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\"\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=DynamoDB_20120810.GetItem";

    let payload = json!({
        "TableName": "",
        "Key": "",
        "AttributesToGet": "",
        "ConsistentRead": "",
        "ReturnConsumedCapacity": "",
        "ProjectionExpression": "",
        "ExpressionAttributeNames": ""
    });

    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 '{
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "Key": "",\n  "AttributesToGet": "",\n  "ConsistentRead": "",\n  "ReturnConsumedCapacity": "",\n  "ProjectionExpression": "",\n  "ExpressionAttributeNames": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "Key": "",
  "AttributesToGet": "",
  "ConsistentRead": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "ExpressionAttributeNames": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.GetItem")! 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=DynamoDB_20120810.ImportTable");

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  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:ClientToken ""
                                                                                                      :S3BucketSource ""
                                                                                                      :InputFormat ""
                                                                                                      :InputFormatOptions ""
                                                                                                      :InputCompressionType ""
                                                                                                      :TableCreationParameters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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=DynamoDB_20120810.ImportTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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=DynamoDB_20120810.ImportTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable"

	payload := strings.NewReader("{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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: 159

{
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable")
  .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=DynamoDB_20120810.ImportTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientToken: '',
  S3BucketSource: '',
  InputFormat: '',
  InputFormatOptions: '',
  InputCompressionType: '',
  TableCreationParameters: ''
});

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=DynamoDB_20120810.ImportTable');
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=DynamoDB_20120810.ImportTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    S3BucketSource: '',
    InputFormat: '',
    InputFormatOptions: '',
    InputCompressionType: '',
    TableCreationParameters: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","S3BucketSource":"","InputFormat":"","InputFormatOptions":"","InputCompressionType":"","TableCreationParameters":""}'
};

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=DynamoDB_20120810.ImportTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientToken": "",\n  "S3BucketSource": "",\n  "InputFormat": "",\n  "InputFormatOptions": "",\n  "InputCompressionType": "",\n  "TableCreationParameters": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable")
  .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({
  ClientToken: '',
  S3BucketSource: '',
  InputFormat: '',
  InputFormatOptions: '',
  InputCompressionType: '',
  TableCreationParameters: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientToken: '',
    S3BucketSource: '',
    InputFormat: '',
    InputFormatOptions: '',
    InputCompressionType: '',
    TableCreationParameters: ''
  },
  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=DynamoDB_20120810.ImportTable');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ClientToken: '',
  S3BucketSource: '',
  InputFormat: '',
  InputFormatOptions: '',
  InputCompressionType: '',
  TableCreationParameters: ''
});

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=DynamoDB_20120810.ImportTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    S3BucketSource: '',
    InputFormat: '',
    InputFormatOptions: '',
    InputCompressionType: '',
    TableCreationParameters: ''
  }
};

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=DynamoDB_20120810.ImportTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","S3BucketSource":"","InputFormat":"","InputFormatOptions":"","InputCompressionType":"","TableCreationParameters":""}'
};

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 = @{ @"ClientToken": @"",
                              @"S3BucketSource": @"",
                              @"InputFormat": @"",
                              @"InputFormatOptions": @"",
                              @"InputCompressionType": @"",
                              @"TableCreationParameters": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable"]
                                                       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=DynamoDB_20120810.ImportTable" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable",
  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([
    'ClientToken' => '',
    'S3BucketSource' => '',
    'InputFormat' => '',
    'InputFormatOptions' => '',
    'InputCompressionType' => '',
    'TableCreationParameters' => ''
  ]),
  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=DynamoDB_20120810.ImportTable', [
  'body' => '{
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientToken' => '',
  'S3BucketSource' => '',
  'InputFormat' => '',
  'InputFormatOptions' => '',
  'InputCompressionType' => '',
  'TableCreationParameters' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ClientToken' => '',
  'S3BucketSource' => '',
  'InputFormat' => '',
  'InputFormatOptions' => '',
  'InputCompressionType' => '',
  'TableCreationParameters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable');
$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=DynamoDB_20120810.ImportTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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=DynamoDB_20120810.ImportTable"

payload = {
    "ClientToken": "",
    "S3BucketSource": "",
    "InputFormat": "",
    "InputFormatOptions": "",
    "InputCompressionType": "",
    "TableCreationParameters": ""
}
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=DynamoDB_20120810.ImportTable"

payload <- "{\n  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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=DynamoDB_20120810.ImportTable")

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  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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  \"ClientToken\": \"\",\n  \"S3BucketSource\": \"\",\n  \"InputFormat\": \"\",\n  \"InputFormatOptions\": \"\",\n  \"InputCompressionType\": \"\",\n  \"TableCreationParameters\": \"\"\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=DynamoDB_20120810.ImportTable";

    let payload = json!({
        "ClientToken": "",
        "S3BucketSource": "",
        "InputFormat": "",
        "InputFormatOptions": "",
        "InputCompressionType": "",
        "TableCreationParameters": ""
    });

    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 '{
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientToken": "",\n  "S3BucketSource": "",\n  "InputFormat": "",\n  "InputFormatOptions": "",\n  "InputCompressionType": "",\n  "TableCreationParameters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientToken": "",
  "S3BucketSource": "",
  "InputFormat": "",
  "InputFormatOptions": "",
  "InputCompressionType": "",
  "TableCreationParameters": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ImportTable")! 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=DynamoDB_20120810.ListBackups");

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  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:TableName ""
                                                                                                      :Limit ""
                                                                                                      :TimeRangeLowerBound ""
                                                                                                      :TimeRangeUpperBound ""
                                                                                                      :ExclusiveStartBackupArn ""
                                                                                                      :BackupType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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=DynamoDB_20120810.ListBackups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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=DynamoDB_20120810.ListBackups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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: 147

{
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups")
  .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=DynamoDB_20120810.ListBackups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  Limit: '',
  TimeRangeLowerBound: '',
  TimeRangeUpperBound: '',
  ExclusiveStartBackupArn: '',
  BackupType: ''
});

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=DynamoDB_20120810.ListBackups');
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=DynamoDB_20120810.ListBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Limit: '',
    TimeRangeLowerBound: '',
    TimeRangeUpperBound: '',
    ExclusiveStartBackupArn: '',
    BackupType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Limit":"","TimeRangeLowerBound":"","TimeRangeUpperBound":"","ExclusiveStartBackupArn":"","BackupType":""}'
};

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=DynamoDB_20120810.ListBackups',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "Limit": "",\n  "TimeRangeLowerBound": "",\n  "TimeRangeUpperBound": "",\n  "ExclusiveStartBackupArn": "",\n  "BackupType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups")
  .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({
  TableName: '',
  Limit: '',
  TimeRangeLowerBound: '',
  TimeRangeUpperBound: '',
  ExclusiveStartBackupArn: '',
  BackupType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    Limit: '',
    TimeRangeLowerBound: '',
    TimeRangeUpperBound: '',
    ExclusiveStartBackupArn: '',
    BackupType: ''
  },
  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=DynamoDB_20120810.ListBackups');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  Limit: '',
  TimeRangeLowerBound: '',
  TimeRangeUpperBound: '',
  ExclusiveStartBackupArn: '',
  BackupType: ''
});

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=DynamoDB_20120810.ListBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Limit: '',
    TimeRangeLowerBound: '',
    TimeRangeUpperBound: '',
    ExclusiveStartBackupArn: '',
    BackupType: ''
  }
};

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=DynamoDB_20120810.ListBackups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Limit":"","TimeRangeLowerBound":"","TimeRangeUpperBound":"","ExclusiveStartBackupArn":"","BackupType":""}'
};

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 = @{ @"TableName": @"",
                              @"Limit": @"",
                              @"TimeRangeLowerBound": @"",
                              @"TimeRangeUpperBound": @"",
                              @"ExclusiveStartBackupArn": @"",
                              @"BackupType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups"]
                                                       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=DynamoDB_20120810.ListBackups" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups",
  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([
    'TableName' => '',
    'Limit' => '',
    'TimeRangeLowerBound' => '',
    'TimeRangeUpperBound' => '',
    'ExclusiveStartBackupArn' => '',
    'BackupType' => ''
  ]),
  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=DynamoDB_20120810.ListBackups', [
  'body' => '{
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'Limit' => '',
  'TimeRangeLowerBound' => '',
  'TimeRangeUpperBound' => '',
  'ExclusiveStartBackupArn' => '',
  'BackupType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'Limit' => '',
  'TimeRangeLowerBound' => '',
  'TimeRangeUpperBound' => '',
  'ExclusiveStartBackupArn' => '',
  'BackupType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups');
$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=DynamoDB_20120810.ListBackups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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=DynamoDB_20120810.ListBackups"

payload = {
    "TableName": "",
    "Limit": "",
    "TimeRangeLowerBound": "",
    "TimeRangeUpperBound": "",
    "ExclusiveStartBackupArn": "",
    "BackupType": ""
}
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=DynamoDB_20120810.ListBackups"

payload <- "{\n  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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=DynamoDB_20120810.ListBackups")

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  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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  \"TableName\": \"\",\n  \"Limit\": \"\",\n  \"TimeRangeLowerBound\": \"\",\n  \"TimeRangeUpperBound\": \"\",\n  \"ExclusiveStartBackupArn\": \"\",\n  \"BackupType\": \"\"\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=DynamoDB_20120810.ListBackups";

    let payload = json!({
        "TableName": "",
        "Limit": "",
        "TimeRangeLowerBound": "",
        "TimeRangeUpperBound": "",
        "ExclusiveStartBackupArn": "",
        "BackupType": ""
    });

    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 '{
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "Limit": "",\n  "TimeRangeLowerBound": "",\n  "TimeRangeUpperBound": "",\n  "ExclusiveStartBackupArn": "",\n  "BackupType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "Limit": "",
  "TimeRangeLowerBound": "",
  "TimeRangeUpperBound": "",
  "ExclusiveStartBackupArn": "",
  "BackupType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListBackups")! 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=DynamoDB_20120810.ListContributorInsights");

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  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:TableName ""
                                                                                                                  :NextToken ""
                                                                                                                  :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 60

{
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights")
  .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=DynamoDB_20120810.ListContributorInsights")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights');
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=DynamoDB_20120810.ListContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights")
  .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({TableName: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TableName": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"]
                                                       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=DynamoDB_20120810.ListContributorInsights" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights",
  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([
    'TableName' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights', [
  'body' => '{
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights');
$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=DynamoDB_20120810.ListContributorInsights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"

payload = {
    "TableName": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights"

payload <- "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights")

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  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TableName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights";

    let payload = json!({
        "TableName": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListContributorInsights")! 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=DynamoDB_20120810.ListExports");

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  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:TableArn ""
                                                                                                      :MaxResults ""
                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports"

	payload := strings.NewReader("{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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

{
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports")
  .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=DynamoDB_20120810.ListExports")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableArn: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports');
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=DynamoDB_20120810.ListExports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableArn: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableArn": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports")
  .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({TableArn: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableArn: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableArn: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableArn: '', MaxResults: '', NextToken: ''}
};

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=DynamoDB_20120810.ListExports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","MaxResults":"","NextToken":""}'
};

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 = @{ @"TableArn": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports"]
                                                       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=DynamoDB_20120810.ListExports" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports",
  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([
    'TableArn' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  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=DynamoDB_20120810.ListExports', [
  'body' => '{
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableArn' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableArn' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports');
$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=DynamoDB_20120810.ListExports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListExports"

payload = {
    "TableArn": "",
    "MaxResults": "",
    "NextToken": ""
}
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=DynamoDB_20120810.ListExports"

payload <- "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListExports")

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  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TableArn\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports";

    let payload = json!({
        "TableArn": "",
        "MaxResults": "",
        "NextToken": ""
    });

    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 '{
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableArn": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableArn": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListExports")! 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=DynamoDB_20120810.ListGlobalTables");

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  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:ExclusiveStartGlobalTableName ""
                                                                                                           :Limit ""
                                                                                                           :RegionName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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=DynamoDB_20120810.ListGlobalTables"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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=DynamoDB_20120810.ListGlobalTables");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables"

	payload := strings.NewReader("{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables")
  .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=DynamoDB_20120810.ListGlobalTables")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ExclusiveStartGlobalTableName: '',
  Limit: '',
  RegionName: ''
});

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=DynamoDB_20120810.ListGlobalTables');
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=DynamoDB_20120810.ListGlobalTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExclusiveStartGlobalTableName: '', Limit: '', RegionName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ExclusiveStartGlobalTableName":"","Limit":"","RegionName":""}'
};

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=DynamoDB_20120810.ListGlobalTables',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ExclusiveStartGlobalTableName": "",\n  "Limit": "",\n  "RegionName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables")
  .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({ExclusiveStartGlobalTableName: '', Limit: '', RegionName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ExclusiveStartGlobalTableName: '', Limit: '', RegionName: ''},
  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=DynamoDB_20120810.ListGlobalTables');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ExclusiveStartGlobalTableName: '',
  Limit: '',
  RegionName: ''
});

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=DynamoDB_20120810.ListGlobalTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExclusiveStartGlobalTableName: '', Limit: '', RegionName: ''}
};

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=DynamoDB_20120810.ListGlobalTables';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ExclusiveStartGlobalTableName":"","Limit":"","RegionName":""}'
};

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 = @{ @"ExclusiveStartGlobalTableName": @"",
                              @"Limit": @"",
                              @"RegionName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables"]
                                                       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=DynamoDB_20120810.ListGlobalTables" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables",
  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([
    'ExclusiveStartGlobalTableName' => '',
    'Limit' => '',
    'RegionName' => ''
  ]),
  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=DynamoDB_20120810.ListGlobalTables', [
  'body' => '{
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ExclusiveStartGlobalTableName' => '',
  'Limit' => '',
  'RegionName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ExclusiveStartGlobalTableName' => '',
  'Limit' => '',
  'RegionName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables');
$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=DynamoDB_20120810.ListGlobalTables' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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=DynamoDB_20120810.ListGlobalTables"

payload = {
    "ExclusiveStartGlobalTableName": "",
    "Limit": "",
    "RegionName": ""
}
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=DynamoDB_20120810.ListGlobalTables"

payload <- "{\n  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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=DynamoDB_20120810.ListGlobalTables")

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  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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  \"ExclusiveStartGlobalTableName\": \"\",\n  \"Limit\": \"\",\n  \"RegionName\": \"\"\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=DynamoDB_20120810.ListGlobalTables";

    let payload = json!({
        "ExclusiveStartGlobalTableName": "",
        "Limit": "",
        "RegionName": ""
    });

    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 '{
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ExclusiveStartGlobalTableName": "",\n  "Limit": "",\n  "RegionName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ExclusiveStartGlobalTableName": "",
  "Limit": "",
  "RegionName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListGlobalTables")! 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=DynamoDB_20120810.ListImports");

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  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:TableArn ""
                                                                                                      :PageSize ""
                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports"

	payload := strings.NewReader("{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\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: 57

{
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports")
  .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=DynamoDB_20120810.ListImports")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableArn: '',
  PageSize: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports');
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=DynamoDB_20120810.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableArn: '', PageSize: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","PageSize":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableArn": "",\n  "PageSize": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports")
  .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({TableArn: '', PageSize: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableArn: '', PageSize: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableArn: '',
  PageSize: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableArn: '', PageSize: '', NextToken: ''}
};

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=DynamoDB_20120810.ListImports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableArn":"","PageSize":"","NextToken":""}'
};

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 = @{ @"TableArn": @"",
                              @"PageSize": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports"]
                                                       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=DynamoDB_20120810.ListImports" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports",
  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([
    'TableArn' => '',
    'PageSize' => '',
    'NextToken' => ''
  ]),
  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=DynamoDB_20120810.ListImports', [
  'body' => '{
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableArn' => '',
  'PageSize' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableArn' => '',
  'PageSize' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports');
$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=DynamoDB_20120810.ListImports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListImports"

payload = {
    "TableArn": "",
    "PageSize": "",
    "NextToken": ""
}
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=DynamoDB_20120810.ListImports"

payload <- "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListImports")

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  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TableArn\": \"\",\n  \"PageSize\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports";

    let payload = json!({
        "TableArn": "",
        "PageSize": "",
        "NextToken": ""
    });

    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 '{
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableArn": "",\n  "PageSize": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableArn": "",
  "PageSize": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListImports")! 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=DynamoDB_20120810.ListTables");

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  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:ExclusiveStartTableName ""
                                                                                                     :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ListTables"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ListTables");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables"

	payload := strings.NewReader("{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 50

{
  "ExclusiveStartTableName": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables")
  .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=DynamoDB_20120810.ListTables")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ExclusiveStartTableName: '',
  Limit: ''
});

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=DynamoDB_20120810.ListTables');
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=DynamoDB_20120810.ListTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExclusiveStartTableName: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ExclusiveStartTableName":"","Limit":""}'
};

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=DynamoDB_20120810.ListTables',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ExclusiveStartTableName": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables")
  .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({ExclusiveStartTableName: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ExclusiveStartTableName: '', Limit: ''},
  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=DynamoDB_20120810.ListTables');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ExclusiveStartTableName: '',
  Limit: ''
});

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=DynamoDB_20120810.ListTables',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ExclusiveStartTableName: '', Limit: ''}
};

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=DynamoDB_20120810.ListTables';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ExclusiveStartTableName":"","Limit":""}'
};

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 = @{ @"ExclusiveStartTableName": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables"]
                                                       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=DynamoDB_20120810.ListTables" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables",
  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([
    'ExclusiveStartTableName' => '',
    'Limit' => ''
  ]),
  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=DynamoDB_20120810.ListTables', [
  'body' => '{
  "ExclusiveStartTableName": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ExclusiveStartTableName' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ExclusiveStartTableName' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables');
$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=DynamoDB_20120810.ListTables' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExclusiveStartTableName": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ExclusiveStartTableName": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ListTables"

payload = {
    "ExclusiveStartTableName": "",
    "Limit": ""
}
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=DynamoDB_20120810.ListTables"

payload <- "{\n  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ListTables")

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  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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  \"ExclusiveStartTableName\": \"\",\n  \"Limit\": \"\"\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=DynamoDB_20120810.ListTables";

    let payload = json!({
        "ExclusiveStartTableName": "",
        "Limit": ""
    });

    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 '{
  "ExclusiveStartTableName": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ExclusiveStartTableName": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ExclusiveStartTableName": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTables")! 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=DynamoDB_20120810.ListTagsOfResource");

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  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:ResourceArn ""
                                                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\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

{
  "ResourceArn": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource")
  .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=DynamoDB_20120810.ListTagsOfResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource');
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=DynamoDB_20120810.ListTagsOfResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource")
  .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({ResourceArn: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', NextToken: ''}
};

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=DynamoDB_20120810.ListTagsOfResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","NextToken":""}'
};

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 = @{ @"ResourceArn": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource"]
                                                       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=DynamoDB_20120810.ListTagsOfResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource",
  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([
    'ResourceArn' => '',
    'NextToken' => ''
  ]),
  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=DynamoDB_20120810.ListTagsOfResource', [
  'body' => '{
  "ResourceArn": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource');
$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=DynamoDB_20120810.ListTagsOfResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListTagsOfResource"

payload = {
    "ResourceArn": "",
    "NextToken": ""
}
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=DynamoDB_20120810.ListTagsOfResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\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=DynamoDB_20120810.ListTagsOfResource")

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  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceArn\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource";

    let payload = json!({
        "ResourceArn": "",
        "NextToken": ""
    });

    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 '{
  "ResourceArn": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.ListTagsOfResource")! 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=DynamoDB_20120810.PutItem");

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  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:TableName ""
                                                                                                  :Item ""
                                                                                                  :Expected ""
                                                                                                  :ReturnValues ""
                                                                                                  :ReturnConsumedCapacity ""
                                                                                                  :ReturnItemCollectionMetrics ""
                                                                                                  :ConditionalOperator ""
                                                                                                  :ConditionExpression ""
                                                                                                  :ExpressionAttributeNames ""
                                                                                                  :ExpressionAttributeValues ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.PutItem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.PutItem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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: 271

{
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem")
  .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=DynamoDB_20120810.PutItem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  Item: '',
  Expected: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionalOperator: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.PutItem');
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=DynamoDB_20120810.PutItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Item: '',
    Expected: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionalOperator: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Item":"","Expected":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ConditionalOperator":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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=DynamoDB_20120810.PutItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "Item": "",\n  "Expected": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ConditionalOperator": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem")
  .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({
  TableName: '',
  Item: '',
  Expected: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionalOperator: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    Item: '',
    Expected: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionalOperator: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  },
  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=DynamoDB_20120810.PutItem');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  Item: '',
  Expected: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ConditionalOperator: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.PutItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Item: '',
    Expected: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ConditionalOperator: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

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=DynamoDB_20120810.PutItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Item":"","Expected":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ConditionalOperator":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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 = @{ @"TableName": @"",
                              @"Item": @"",
                              @"Expected": @"",
                              @"ReturnValues": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ReturnItemCollectionMetrics": @"",
                              @"ConditionalOperator": @"",
                              @"ConditionExpression": @"",
                              @"ExpressionAttributeNames": @"",
                              @"ExpressionAttributeValues": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem"]
                                                       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=DynamoDB_20120810.PutItem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem",
  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([
    'TableName' => '',
    'Item' => '',
    'Expected' => '',
    'ReturnValues' => '',
    'ReturnConsumedCapacity' => '',
    'ReturnItemCollectionMetrics' => '',
    'ConditionalOperator' => '',
    'ConditionExpression' => '',
    'ExpressionAttributeNames' => '',
    'ExpressionAttributeValues' => ''
  ]),
  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=DynamoDB_20120810.PutItem', [
  'body' => '{
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'Item' => '',
  'Expected' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ConditionalOperator' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'Item' => '',
  'Expected' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ConditionalOperator' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem');
$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=DynamoDB_20120810.PutItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.PutItem"

payload = {
    "TableName": "",
    "Item": "",
    "Expected": "",
    "ReturnValues": "",
    "ReturnConsumedCapacity": "",
    "ReturnItemCollectionMetrics": "",
    "ConditionalOperator": "",
    "ConditionExpression": "",
    "ExpressionAttributeNames": "",
    "ExpressionAttributeValues": ""
}
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=DynamoDB_20120810.PutItem"

payload <- "{\n  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.PutItem")

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  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Item\": \"\",\n  \"Expected\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.PutItem";

    let payload = json!({
        "TableName": "",
        "Item": "",
        "Expected": "",
        "ReturnValues": "",
        "ReturnConsumedCapacity": "",
        "ReturnItemCollectionMetrics": "",
        "ConditionalOperator": "",
        "ConditionExpression": "",
        "ExpressionAttributeNames": "",
        "ExpressionAttributeValues": ""
    });

    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 '{
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "Item": "",\n  "Expected": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ConditionalOperator": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "Item": "",
  "Expected": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ConditionalOperator": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.PutItem")! 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=DynamoDB_20120810.Query");

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:TableName ""
                                                                                                :IndexName ""
                                                                                                :Select ""
                                                                                                :AttributesToGet ""
                                                                                                :Limit ""
                                                                                                :ConsistentRead ""
                                                                                                :KeyConditions ""
                                                                                                :QueryFilter ""
                                                                                                :ConditionalOperator ""
                                                                                                :ScanIndexForward ""
                                                                                                :ExclusiveStartKey ""
                                                                                                :ReturnConsumedCapacity ""
                                                                                                :ProjectionExpression ""
                                                                                                :FilterExpression ""
                                                                                                :KeyConditionExpression ""
                                                                                                :ExpressionAttributeNames ""
                                                                                                :ExpressionAttributeValues ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.Query"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.Query");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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: 435

{
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query")
  .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=DynamoDB_20120810.Query")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  IndexName: '',
  Select: '',
  AttributesToGet: '',
  Limit: '',
  ConsistentRead: '',
  KeyConditions: '',
  QueryFilter: '',
  ConditionalOperator: '',
  ScanIndexForward: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  FilterExpression: '',
  KeyConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.Query');
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=DynamoDB_20120810.Query',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    IndexName: '',
    Select: '',
    AttributesToGet: '',
    Limit: '',
    ConsistentRead: '',
    KeyConditions: '',
    QueryFilter: '',
    ConditionalOperator: '',
    ScanIndexForward: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    FilterExpression: '',
    KeyConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","Select":"","AttributesToGet":"","Limit":"","ConsistentRead":"","KeyConditions":"","QueryFilter":"","ConditionalOperator":"","ScanIndexForward":"","ExclusiveStartKey":"","ReturnConsumedCapacity":"","ProjectionExpression":"","FilterExpression":"","KeyConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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=DynamoDB_20120810.Query',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "IndexName": "",\n  "Select": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "ConsistentRead": "",\n  "KeyConditions": "",\n  "QueryFilter": "",\n  "ConditionalOperator": "",\n  "ScanIndexForward": "",\n  "ExclusiveStartKey": "",\n  "ReturnConsumedCapacity": "",\n  "ProjectionExpression": "",\n  "FilterExpression": "",\n  "KeyConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query")
  .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({
  TableName: '',
  IndexName: '',
  Select: '',
  AttributesToGet: '',
  Limit: '',
  ConsistentRead: '',
  KeyConditions: '',
  QueryFilter: '',
  ConditionalOperator: '',
  ScanIndexForward: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  FilterExpression: '',
  KeyConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    IndexName: '',
    Select: '',
    AttributesToGet: '',
    Limit: '',
    ConsistentRead: '',
    KeyConditions: '',
    QueryFilter: '',
    ConditionalOperator: '',
    ScanIndexForward: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    FilterExpression: '',
    KeyConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  },
  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=DynamoDB_20120810.Query');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  IndexName: '',
  Select: '',
  AttributesToGet: '',
  Limit: '',
  ConsistentRead: '',
  KeyConditions: '',
  QueryFilter: '',
  ConditionalOperator: '',
  ScanIndexForward: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  ProjectionExpression: '',
  FilterExpression: '',
  KeyConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.Query',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    IndexName: '',
    Select: '',
    AttributesToGet: '',
    Limit: '',
    ConsistentRead: '',
    KeyConditions: '',
    QueryFilter: '',
    ConditionalOperator: '',
    ScanIndexForward: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    ProjectionExpression: '',
    FilterExpression: '',
    KeyConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

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=DynamoDB_20120810.Query';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","Select":"","AttributesToGet":"","Limit":"","ConsistentRead":"","KeyConditions":"","QueryFilter":"","ConditionalOperator":"","ScanIndexForward":"","ExclusiveStartKey":"","ReturnConsumedCapacity":"","ProjectionExpression":"","FilterExpression":"","KeyConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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 = @{ @"TableName": @"",
                              @"IndexName": @"",
                              @"Select": @"",
                              @"AttributesToGet": @"",
                              @"Limit": @"",
                              @"ConsistentRead": @"",
                              @"KeyConditions": @"",
                              @"QueryFilter": @"",
                              @"ConditionalOperator": @"",
                              @"ScanIndexForward": @"",
                              @"ExclusiveStartKey": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ProjectionExpression": @"",
                              @"FilterExpression": @"",
                              @"KeyConditionExpression": @"",
                              @"ExpressionAttributeNames": @"",
                              @"ExpressionAttributeValues": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query"]
                                                       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=DynamoDB_20120810.Query" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query",
  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([
    'TableName' => '',
    'IndexName' => '',
    'Select' => '',
    'AttributesToGet' => '',
    'Limit' => '',
    'ConsistentRead' => '',
    'KeyConditions' => '',
    'QueryFilter' => '',
    'ConditionalOperator' => '',
    'ScanIndexForward' => '',
    'ExclusiveStartKey' => '',
    'ReturnConsumedCapacity' => '',
    'ProjectionExpression' => '',
    'FilterExpression' => '',
    'KeyConditionExpression' => '',
    'ExpressionAttributeNames' => '',
    'ExpressionAttributeValues' => ''
  ]),
  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=DynamoDB_20120810.Query', [
  'body' => '{
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'Select' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'ConsistentRead' => '',
  'KeyConditions' => '',
  'QueryFilter' => '',
  'ConditionalOperator' => '',
  'ScanIndexForward' => '',
  'ExclusiveStartKey' => '',
  'ReturnConsumedCapacity' => '',
  'ProjectionExpression' => '',
  'FilterExpression' => '',
  'KeyConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'Select' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'ConsistentRead' => '',
  'KeyConditions' => '',
  'QueryFilter' => '',
  'ConditionalOperator' => '',
  'ScanIndexForward' => '',
  'ExclusiveStartKey' => '',
  'ReturnConsumedCapacity' => '',
  'ProjectionExpression' => '',
  'FilterExpression' => '',
  'KeyConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query');
$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=DynamoDB_20120810.Query' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.Query"

payload = {
    "TableName": "",
    "IndexName": "",
    "Select": "",
    "AttributesToGet": "",
    "Limit": "",
    "ConsistentRead": "",
    "KeyConditions": "",
    "QueryFilter": "",
    "ConditionalOperator": "",
    "ScanIndexForward": "",
    "ExclusiveStartKey": "",
    "ReturnConsumedCapacity": "",
    "ProjectionExpression": "",
    "FilterExpression": "",
    "KeyConditionExpression": "",
    "ExpressionAttributeNames": "",
    "ExpressionAttributeValues": ""
}
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=DynamoDB_20120810.Query"

payload <- "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.Query")

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"Select\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"ConsistentRead\": \"\",\n  \"KeyConditions\": \"\",\n  \"QueryFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ScanIndexForward\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"KeyConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.Query";

    let payload = json!({
        "TableName": "",
        "IndexName": "",
        "Select": "",
        "AttributesToGet": "",
        "Limit": "",
        "ConsistentRead": "",
        "KeyConditions": "",
        "QueryFilter": "",
        "ConditionalOperator": "",
        "ScanIndexForward": "",
        "ExclusiveStartKey": "",
        "ReturnConsumedCapacity": "",
        "ProjectionExpression": "",
        "FilterExpression": "",
        "KeyConditionExpression": "",
        "ExpressionAttributeNames": "",
        "ExpressionAttributeValues": ""
    });

    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 '{
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "IndexName": "",\n  "Select": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "ConsistentRead": "",\n  "KeyConditions": "",\n  "QueryFilter": "",\n  "ConditionalOperator": "",\n  "ScanIndexForward": "",\n  "ExclusiveStartKey": "",\n  "ReturnConsumedCapacity": "",\n  "ProjectionExpression": "",\n  "FilterExpression": "",\n  "KeyConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "IndexName": "",
  "Select": "",
  "AttributesToGet": "",
  "Limit": "",
  "ConsistentRead": "",
  "KeyConditions": "",
  "QueryFilter": "",
  "ConditionalOperator": "",
  "ScanIndexForward": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "KeyConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Query")! 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=DynamoDB_20120810.RestoreTableFromBackup");

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  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:TargetTableName ""
                                                                                                                 :BackupArn ""
                                                                                                                 :BillingModeOverride ""
                                                                                                                 :GlobalSecondaryIndexOverride ""
                                                                                                                 :LocalSecondaryIndexOverride ""
                                                                                                                 :ProvisionedThroughputOverride ""
                                                                                                                 :SSESpecificationOverride ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableFromBackup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableFromBackup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup"

	payload := strings.NewReader("{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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: 223

{
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup")
  .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=DynamoDB_20120810.RestoreTableFromBackup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TargetTableName: '',
  BackupArn: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
});

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=DynamoDB_20120810.RestoreTableFromBackup');
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=DynamoDB_20120810.RestoreTableFromBackup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TargetTableName: '',
    BackupArn: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetTableName":"","BackupArn":"","BillingModeOverride":"","GlobalSecondaryIndexOverride":"","LocalSecondaryIndexOverride":"","ProvisionedThroughputOverride":"","SSESpecificationOverride":""}'
};

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=DynamoDB_20120810.RestoreTableFromBackup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TargetTableName": "",\n  "BackupArn": "",\n  "BillingModeOverride": "",\n  "GlobalSecondaryIndexOverride": "",\n  "LocalSecondaryIndexOverride": "",\n  "ProvisionedThroughputOverride": "",\n  "SSESpecificationOverride": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup")
  .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({
  TargetTableName: '',
  BackupArn: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TargetTableName: '',
    BackupArn: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  },
  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=DynamoDB_20120810.RestoreTableFromBackup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TargetTableName: '',
  BackupArn: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
});

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=DynamoDB_20120810.RestoreTableFromBackup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TargetTableName: '',
    BackupArn: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  }
};

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=DynamoDB_20120810.RestoreTableFromBackup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetTableName":"","BackupArn":"","BillingModeOverride":"","GlobalSecondaryIndexOverride":"","LocalSecondaryIndexOverride":"","ProvisionedThroughputOverride":"","SSESpecificationOverride":""}'
};

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 = @{ @"TargetTableName": @"",
                              @"BackupArn": @"",
                              @"BillingModeOverride": @"",
                              @"GlobalSecondaryIndexOverride": @"",
                              @"LocalSecondaryIndexOverride": @"",
                              @"ProvisionedThroughputOverride": @"",
                              @"SSESpecificationOverride": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup"]
                                                       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=DynamoDB_20120810.RestoreTableFromBackup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup",
  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([
    'TargetTableName' => '',
    'BackupArn' => '',
    'BillingModeOverride' => '',
    'GlobalSecondaryIndexOverride' => '',
    'LocalSecondaryIndexOverride' => '',
    'ProvisionedThroughputOverride' => '',
    'SSESpecificationOverride' => ''
  ]),
  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=DynamoDB_20120810.RestoreTableFromBackup', [
  'body' => '{
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TargetTableName' => '',
  'BackupArn' => '',
  'BillingModeOverride' => '',
  'GlobalSecondaryIndexOverride' => '',
  'LocalSecondaryIndexOverride' => '',
  'ProvisionedThroughputOverride' => '',
  'SSESpecificationOverride' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TargetTableName' => '',
  'BackupArn' => '',
  'BillingModeOverride' => '',
  'GlobalSecondaryIndexOverride' => '',
  'LocalSecondaryIndexOverride' => '',
  'ProvisionedThroughputOverride' => '',
  'SSESpecificationOverride' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup');
$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=DynamoDB_20120810.RestoreTableFromBackup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableFromBackup"

payload = {
    "TargetTableName": "",
    "BackupArn": "",
    "BillingModeOverride": "",
    "GlobalSecondaryIndexOverride": "",
    "LocalSecondaryIndexOverride": "",
    "ProvisionedThroughputOverride": "",
    "SSESpecificationOverride": ""
}
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=DynamoDB_20120810.RestoreTableFromBackup"

payload <- "{\n  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableFromBackup")

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  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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  \"TargetTableName\": \"\",\n  \"BackupArn\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableFromBackup";

    let payload = json!({
        "TargetTableName": "",
        "BackupArn": "",
        "BillingModeOverride": "",
        "GlobalSecondaryIndexOverride": "",
        "LocalSecondaryIndexOverride": "",
        "ProvisionedThroughputOverride": "",
        "SSESpecificationOverride": ""
    });

    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 '{
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TargetTableName": "",\n  "BackupArn": "",\n  "BillingModeOverride": "",\n  "GlobalSecondaryIndexOverride": "",\n  "LocalSecondaryIndexOverride": "",\n  "ProvisionedThroughputOverride": "",\n  "SSESpecificationOverride": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TargetTableName": "",
  "BackupArn": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableFromBackup")! 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=DynamoDB_20120810.RestoreTableToPointInTime");

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  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:SourceTableArn ""
                                                                                                                    :SourceTableName ""
                                                                                                                    :TargetTableName ""
                                                                                                                    :UseLatestRestorableTime ""
                                                                                                                    :RestoreDateTime ""
                                                                                                                    :BillingModeOverride ""
                                                                                                                    :GlobalSecondaryIndexOverride ""
                                                                                                                    :LocalSecondaryIndexOverride ""
                                                                                                                    :ProvisionedThroughputOverride ""
                                                                                                                    :SSESpecificationOverride ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableToPointInTime"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableToPointInTime");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime"

	payload := strings.NewReader("{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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: 311

{
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime")
  .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=DynamoDB_20120810.RestoreTableToPointInTime")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SourceTableArn: '',
  SourceTableName: '',
  TargetTableName: '',
  UseLatestRestorableTime: '',
  RestoreDateTime: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
});

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=DynamoDB_20120810.RestoreTableToPointInTime');
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=DynamoDB_20120810.RestoreTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceTableArn: '',
    SourceTableName: '',
    TargetTableName: '',
    UseLatestRestorableTime: '',
    RestoreDateTime: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceTableArn":"","SourceTableName":"","TargetTableName":"","UseLatestRestorableTime":"","RestoreDateTime":"","BillingModeOverride":"","GlobalSecondaryIndexOverride":"","LocalSecondaryIndexOverride":"","ProvisionedThroughputOverride":"","SSESpecificationOverride":""}'
};

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=DynamoDB_20120810.RestoreTableToPointInTime',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceTableArn": "",\n  "SourceTableName": "",\n  "TargetTableName": "",\n  "UseLatestRestorableTime": "",\n  "RestoreDateTime": "",\n  "BillingModeOverride": "",\n  "GlobalSecondaryIndexOverride": "",\n  "LocalSecondaryIndexOverride": "",\n  "ProvisionedThroughputOverride": "",\n  "SSESpecificationOverride": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime")
  .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({
  SourceTableArn: '',
  SourceTableName: '',
  TargetTableName: '',
  UseLatestRestorableTime: '',
  RestoreDateTime: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SourceTableArn: '',
    SourceTableName: '',
    TargetTableName: '',
    UseLatestRestorableTime: '',
    RestoreDateTime: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  },
  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=DynamoDB_20120810.RestoreTableToPointInTime');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SourceTableArn: '',
  SourceTableName: '',
  TargetTableName: '',
  UseLatestRestorableTime: '',
  RestoreDateTime: '',
  BillingModeOverride: '',
  GlobalSecondaryIndexOverride: '',
  LocalSecondaryIndexOverride: '',
  ProvisionedThroughputOverride: '',
  SSESpecificationOverride: ''
});

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=DynamoDB_20120810.RestoreTableToPointInTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceTableArn: '',
    SourceTableName: '',
    TargetTableName: '',
    UseLatestRestorableTime: '',
    RestoreDateTime: '',
    BillingModeOverride: '',
    GlobalSecondaryIndexOverride: '',
    LocalSecondaryIndexOverride: '',
    ProvisionedThroughputOverride: '',
    SSESpecificationOverride: ''
  }
};

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=DynamoDB_20120810.RestoreTableToPointInTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceTableArn":"","SourceTableName":"","TargetTableName":"","UseLatestRestorableTime":"","RestoreDateTime":"","BillingModeOverride":"","GlobalSecondaryIndexOverride":"","LocalSecondaryIndexOverride":"","ProvisionedThroughputOverride":"","SSESpecificationOverride":""}'
};

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 = @{ @"SourceTableArn": @"",
                              @"SourceTableName": @"",
                              @"TargetTableName": @"",
                              @"UseLatestRestorableTime": @"",
                              @"RestoreDateTime": @"",
                              @"BillingModeOverride": @"",
                              @"GlobalSecondaryIndexOverride": @"",
                              @"LocalSecondaryIndexOverride": @"",
                              @"ProvisionedThroughputOverride": @"",
                              @"SSESpecificationOverride": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime"]
                                                       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=DynamoDB_20120810.RestoreTableToPointInTime" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime",
  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([
    'SourceTableArn' => '',
    'SourceTableName' => '',
    'TargetTableName' => '',
    'UseLatestRestorableTime' => '',
    'RestoreDateTime' => '',
    'BillingModeOverride' => '',
    'GlobalSecondaryIndexOverride' => '',
    'LocalSecondaryIndexOverride' => '',
    'ProvisionedThroughputOverride' => '',
    'SSESpecificationOverride' => ''
  ]),
  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=DynamoDB_20120810.RestoreTableToPointInTime', [
  'body' => '{
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceTableArn' => '',
  'SourceTableName' => '',
  'TargetTableName' => '',
  'UseLatestRestorableTime' => '',
  'RestoreDateTime' => '',
  'BillingModeOverride' => '',
  'GlobalSecondaryIndexOverride' => '',
  'LocalSecondaryIndexOverride' => '',
  'ProvisionedThroughputOverride' => '',
  'SSESpecificationOverride' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SourceTableArn' => '',
  'SourceTableName' => '',
  'TargetTableName' => '',
  'UseLatestRestorableTime' => '',
  'RestoreDateTime' => '',
  'BillingModeOverride' => '',
  'GlobalSecondaryIndexOverride' => '',
  'LocalSecondaryIndexOverride' => '',
  'ProvisionedThroughputOverride' => '',
  'SSESpecificationOverride' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime');
$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=DynamoDB_20120810.RestoreTableToPointInTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableToPointInTime"

payload = {
    "SourceTableArn": "",
    "SourceTableName": "",
    "TargetTableName": "",
    "UseLatestRestorableTime": "",
    "RestoreDateTime": "",
    "BillingModeOverride": "",
    "GlobalSecondaryIndexOverride": "",
    "LocalSecondaryIndexOverride": "",
    "ProvisionedThroughputOverride": "",
    "SSESpecificationOverride": ""
}
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=DynamoDB_20120810.RestoreTableToPointInTime"

payload <- "{\n  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableToPointInTime")

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  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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  \"SourceTableArn\": \"\",\n  \"SourceTableName\": \"\",\n  \"TargetTableName\": \"\",\n  \"UseLatestRestorableTime\": \"\",\n  \"RestoreDateTime\": \"\",\n  \"BillingModeOverride\": \"\",\n  \"GlobalSecondaryIndexOverride\": \"\",\n  \"LocalSecondaryIndexOverride\": \"\",\n  \"ProvisionedThroughputOverride\": \"\",\n  \"SSESpecificationOverride\": \"\"\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=DynamoDB_20120810.RestoreTableToPointInTime";

    let payload = json!({
        "SourceTableArn": "",
        "SourceTableName": "",
        "TargetTableName": "",
        "UseLatestRestorableTime": "",
        "RestoreDateTime": "",
        "BillingModeOverride": "",
        "GlobalSecondaryIndexOverride": "",
        "LocalSecondaryIndexOverride": "",
        "ProvisionedThroughputOverride": "",
        "SSESpecificationOverride": ""
    });

    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 '{
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceTableArn": "",\n  "SourceTableName": "",\n  "TargetTableName": "",\n  "UseLatestRestorableTime": "",\n  "RestoreDateTime": "",\n  "BillingModeOverride": "",\n  "GlobalSecondaryIndexOverride": "",\n  "LocalSecondaryIndexOverride": "",\n  "ProvisionedThroughputOverride": "",\n  "SSESpecificationOverride": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SourceTableArn": "",
  "SourceTableName": "",
  "TargetTableName": "",
  "UseLatestRestorableTime": "",
  "RestoreDateTime": "",
  "BillingModeOverride": "",
  "GlobalSecondaryIndexOverride": "",
  "LocalSecondaryIndexOverride": "",
  "ProvisionedThroughputOverride": "",
  "SSESpecificationOverride": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.RestoreTableToPointInTime")! 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=DynamoDB_20120810.Scan");

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan" {:headers {:x-amz-target ""}
                                                                                 :content-type :json
                                                                                 :form-params {:TableName ""
                                                                                               :IndexName ""
                                                                                               :AttributesToGet ""
                                                                                               :Limit ""
                                                                                               :Select ""
                                                                                               :ScanFilter ""
                                                                                               :ConditionalOperator ""
                                                                                               :ExclusiveStartKey ""
                                                                                               :ReturnConsumedCapacity ""
                                                                                               :TotalSegments ""
                                                                                               :Segment ""
                                                                                               :ProjectionExpression ""
                                                                                               :FilterExpression ""
                                                                                               :ExpressionAttributeNames ""
                                                                                               :ExpressionAttributeValues ""
                                                                                               :ConsistentRead ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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=DynamoDB_20120810.Scan"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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=DynamoDB_20120810.Scan");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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: 393

{
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan")
  .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=DynamoDB_20120810.Scan")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  IndexName: '',
  AttributesToGet: '',
  Limit: '',
  Select: '',
  ScanFilter: '',
  ConditionalOperator: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  TotalSegments: '',
  Segment: '',
  ProjectionExpression: '',
  FilterExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: '',
  ConsistentRead: ''
});

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=DynamoDB_20120810.Scan');
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=DynamoDB_20120810.Scan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    IndexName: '',
    AttributesToGet: '',
    Limit: '',
    Select: '',
    ScanFilter: '',
    ConditionalOperator: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    TotalSegments: '',
    Segment: '',
    ProjectionExpression: '',
    FilterExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: '',
    ConsistentRead: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","AttributesToGet":"","Limit":"","Select":"","ScanFilter":"","ConditionalOperator":"","ExclusiveStartKey":"","ReturnConsumedCapacity":"","TotalSegments":"","Segment":"","ProjectionExpression":"","FilterExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":"","ConsistentRead":""}'
};

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=DynamoDB_20120810.Scan',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "IndexName": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "Select": "",\n  "ScanFilter": "",\n  "ConditionalOperator": "",\n  "ExclusiveStartKey": "",\n  "ReturnConsumedCapacity": "",\n  "TotalSegments": "",\n  "Segment": "",\n  "ProjectionExpression": "",\n  "FilterExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": "",\n  "ConsistentRead": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan")
  .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({
  TableName: '',
  IndexName: '',
  AttributesToGet: '',
  Limit: '',
  Select: '',
  ScanFilter: '',
  ConditionalOperator: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  TotalSegments: '',
  Segment: '',
  ProjectionExpression: '',
  FilterExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: '',
  ConsistentRead: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    IndexName: '',
    AttributesToGet: '',
    Limit: '',
    Select: '',
    ScanFilter: '',
    ConditionalOperator: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    TotalSegments: '',
    Segment: '',
    ProjectionExpression: '',
    FilterExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: '',
    ConsistentRead: ''
  },
  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=DynamoDB_20120810.Scan');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  IndexName: '',
  AttributesToGet: '',
  Limit: '',
  Select: '',
  ScanFilter: '',
  ConditionalOperator: '',
  ExclusiveStartKey: '',
  ReturnConsumedCapacity: '',
  TotalSegments: '',
  Segment: '',
  ProjectionExpression: '',
  FilterExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: '',
  ConsistentRead: ''
});

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=DynamoDB_20120810.Scan',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    IndexName: '',
    AttributesToGet: '',
    Limit: '',
    Select: '',
    ScanFilter: '',
    ConditionalOperator: '',
    ExclusiveStartKey: '',
    ReturnConsumedCapacity: '',
    TotalSegments: '',
    Segment: '',
    ProjectionExpression: '',
    FilterExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: '',
    ConsistentRead: ''
  }
};

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=DynamoDB_20120810.Scan';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","AttributesToGet":"","Limit":"","Select":"","ScanFilter":"","ConditionalOperator":"","ExclusiveStartKey":"","ReturnConsumedCapacity":"","TotalSegments":"","Segment":"","ProjectionExpression":"","FilterExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":"","ConsistentRead":""}'
};

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 = @{ @"TableName": @"",
                              @"IndexName": @"",
                              @"AttributesToGet": @"",
                              @"Limit": @"",
                              @"Select": @"",
                              @"ScanFilter": @"",
                              @"ConditionalOperator": @"",
                              @"ExclusiveStartKey": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"TotalSegments": @"",
                              @"Segment": @"",
                              @"ProjectionExpression": @"",
                              @"FilterExpression": @"",
                              @"ExpressionAttributeNames": @"",
                              @"ExpressionAttributeValues": @"",
                              @"ConsistentRead": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan"]
                                                       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=DynamoDB_20120810.Scan" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan",
  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([
    'TableName' => '',
    'IndexName' => '',
    'AttributesToGet' => '',
    'Limit' => '',
    'Select' => '',
    'ScanFilter' => '',
    'ConditionalOperator' => '',
    'ExclusiveStartKey' => '',
    'ReturnConsumedCapacity' => '',
    'TotalSegments' => '',
    'Segment' => '',
    'ProjectionExpression' => '',
    'FilterExpression' => '',
    'ExpressionAttributeNames' => '',
    'ExpressionAttributeValues' => '',
    'ConsistentRead' => ''
  ]),
  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=DynamoDB_20120810.Scan', [
  'body' => '{
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'Select' => '',
  'ScanFilter' => '',
  'ConditionalOperator' => '',
  'ExclusiveStartKey' => '',
  'ReturnConsumedCapacity' => '',
  'TotalSegments' => '',
  'Segment' => '',
  'ProjectionExpression' => '',
  'FilterExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => '',
  'ConsistentRead' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'AttributesToGet' => '',
  'Limit' => '',
  'Select' => '',
  'ScanFilter' => '',
  'ConditionalOperator' => '',
  'ExclusiveStartKey' => '',
  'ReturnConsumedCapacity' => '',
  'TotalSegments' => '',
  'Segment' => '',
  'ProjectionExpression' => '',
  'FilterExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => '',
  'ConsistentRead' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan');
$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=DynamoDB_20120810.Scan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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=DynamoDB_20120810.Scan"

payload = {
    "TableName": "",
    "IndexName": "",
    "AttributesToGet": "",
    "Limit": "",
    "Select": "",
    "ScanFilter": "",
    "ConditionalOperator": "",
    "ExclusiveStartKey": "",
    "ReturnConsumedCapacity": "",
    "TotalSegments": "",
    "Segment": "",
    "ProjectionExpression": "",
    "FilterExpression": "",
    "ExpressionAttributeNames": "",
    "ExpressionAttributeValues": "",
    "ConsistentRead": ""
}
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=DynamoDB_20120810.Scan"

payload <- "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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=DynamoDB_20120810.Scan")

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"AttributesToGet\": \"\",\n  \"Limit\": \"\",\n  \"Select\": \"\",\n  \"ScanFilter\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ExclusiveStartKey\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"TotalSegments\": \"\",\n  \"Segment\": \"\",\n  \"ProjectionExpression\": \"\",\n  \"FilterExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\",\n  \"ConsistentRead\": \"\"\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=DynamoDB_20120810.Scan";

    let payload = json!({
        "TableName": "",
        "IndexName": "",
        "AttributesToGet": "",
        "Limit": "",
        "Select": "",
        "ScanFilter": "",
        "ConditionalOperator": "",
        "ExclusiveStartKey": "",
        "ReturnConsumedCapacity": "",
        "TotalSegments": "",
        "Segment": "",
        "ProjectionExpression": "",
        "FilterExpression": "",
        "ExpressionAttributeNames": "",
        "ExpressionAttributeValues": "",
        "ConsistentRead": ""
    });

    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 '{
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "IndexName": "",\n  "AttributesToGet": "",\n  "Limit": "",\n  "Select": "",\n  "ScanFilter": "",\n  "ConditionalOperator": "",\n  "ExclusiveStartKey": "",\n  "ReturnConsumedCapacity": "",\n  "TotalSegments": "",\n  "Segment": "",\n  "ProjectionExpression": "",\n  "FilterExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": "",\n  "ConsistentRead": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "IndexName": "",
  "AttributesToGet": "",
  "Limit": "",
  "Select": "",
  "ScanFilter": "",
  "ConditionalOperator": "",
  "ExclusiveStartKey": "",
  "ReturnConsumedCapacity": "",
  "TotalSegments": "",
  "Segment": "",
  "ProjectionExpression": "",
  "FilterExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": "",
  "ConsistentRead": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.Scan")! 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=DynamoDB_20120810.TagResource");

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  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:ResourceArn ""
                                                                                                      :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\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: 37

{
  "ResourceArn": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\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  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource")
  .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=DynamoDB_20120810.TagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  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=DynamoDB_20120810.TagResource');
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=DynamoDB_20120810.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","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=DynamoDB_20120810.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\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  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource")
  .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({ResourceArn: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', 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=DynamoDB_20120810.TagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  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=DynamoDB_20120810.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', 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=DynamoDB_20120810.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","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 = @{ @"ResourceArn": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource"]
                                                       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=DynamoDB_20120810.TagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource",
  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([
    'ResourceArn' => '',
    '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=DynamoDB_20120810.TagResource', [
  'body' => '{
  "ResourceArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource');
$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=DynamoDB_20120810.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource"

payload = {
    "ResourceArn": "",
    "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=DynamoDB_20120810.TagResource"

payload <- "{\n  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource")

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  \"ResourceArn\": \"\",\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  \"ResourceArn\": \"\",\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=DynamoDB_20120810.TagResource";

    let payload = json!({
        "ResourceArn": "",
        "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 '{
  "ResourceArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TagResource")! 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=DynamoDB_20120810.TransactGetItems");

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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:TransactItems ""
                                                                                                           :ReturnConsumedCapacity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.TransactGetItems"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.TransactGetItems");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems"

	payload := strings.NewReader("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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: 57

{
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems")
  .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=DynamoDB_20120810.TransactGetItems")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TransactItems: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.TransactGetItems');
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=DynamoDB_20120810.TransactGetItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransactItems: '', ReturnConsumedCapacity: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactItems":"","ReturnConsumedCapacity":""}'
};

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=DynamoDB_20120810.TransactGetItems',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransactItems": "",\n  "ReturnConsumedCapacity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems")
  .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({TransactItems: '', ReturnConsumedCapacity: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TransactItems: '', ReturnConsumedCapacity: ''},
  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=DynamoDB_20120810.TransactGetItems');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TransactItems: '',
  ReturnConsumedCapacity: ''
});

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=DynamoDB_20120810.TransactGetItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TransactItems: '', ReturnConsumedCapacity: ''}
};

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=DynamoDB_20120810.TransactGetItems';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactItems":"","ReturnConsumedCapacity":""}'
};

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 = @{ @"TransactItems": @"",
                              @"ReturnConsumedCapacity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems"]
                                                       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=DynamoDB_20120810.TransactGetItems" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems",
  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([
    'TransactItems' => '',
    'ReturnConsumedCapacity' => ''
  ]),
  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=DynamoDB_20120810.TransactGetItems', [
  'body' => '{
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransactItems' => '',
  'ReturnConsumedCapacity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TransactItems' => '',
  'ReturnConsumedCapacity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems');
$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=DynamoDB_20120810.TransactGetItems' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.TransactGetItems"

payload = {
    "TransactItems": "",
    "ReturnConsumedCapacity": ""
}
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=DynamoDB_20120810.TransactGetItems"

payload <- "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.TransactGetItems")

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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\"\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=DynamoDB_20120810.TransactGetItems";

    let payload = json!({
        "TransactItems": "",
        "ReturnConsumedCapacity": ""
    });

    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 '{
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TransactItems": "",\n  "ReturnConsumedCapacity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TransactItems": "",
  "ReturnConsumedCapacity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactGetItems")! 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=DynamoDB_20120810.TransactWriteItems");

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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:TransactItems ""
                                                                                                             :ReturnConsumedCapacity ""
                                                                                                             :ReturnItemCollectionMetrics ""
                                                                                                             :ClientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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=DynamoDB_20120810.TransactWriteItems"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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=DynamoDB_20120810.TransactWriteItems");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems"

	payload := strings.NewReader("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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: 122

{
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems")
  .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=DynamoDB_20120810.TransactWriteItems")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TransactItems: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ClientRequestToken: ''
});

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=DynamoDB_20120810.TransactWriteItems');
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=DynamoDB_20120810.TransactWriteItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TransactItems: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ClientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactItems":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ClientRequestToken":""}'
};

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=DynamoDB_20120810.TransactWriteItems',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransactItems": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ClientRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems")
  .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({
  TransactItems: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ClientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TransactItems: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ClientRequestToken: ''
  },
  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=DynamoDB_20120810.TransactWriteItems');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TransactItems: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  ClientRequestToken: ''
});

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=DynamoDB_20120810.TransactWriteItems',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TransactItems: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    ClientRequestToken: ''
  }
};

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=DynamoDB_20120810.TransactWriteItems';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TransactItems":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","ClientRequestToken":""}'
};

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 = @{ @"TransactItems": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ReturnItemCollectionMetrics": @"",
                              @"ClientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems"]
                                                       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=DynamoDB_20120810.TransactWriteItems" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems",
  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([
    'TransactItems' => '',
    'ReturnConsumedCapacity' => '',
    'ReturnItemCollectionMetrics' => '',
    'ClientRequestToken' => ''
  ]),
  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=DynamoDB_20120810.TransactWriteItems', [
  'body' => '{
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransactItems' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ClientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TransactItems' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'ClientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems');
$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=DynamoDB_20120810.TransactWriteItems' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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=DynamoDB_20120810.TransactWriteItems"

payload = {
    "TransactItems": "",
    "ReturnConsumedCapacity": "",
    "ReturnItemCollectionMetrics": "",
    "ClientRequestToken": ""
}
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=DynamoDB_20120810.TransactWriteItems"

payload <- "{\n  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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=DynamoDB_20120810.TransactWriteItems")

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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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  \"TransactItems\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"ClientRequestToken\": \"\"\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=DynamoDB_20120810.TransactWriteItems";

    let payload = json!({
        "TransactItems": "",
        "ReturnConsumedCapacity": "",
        "ReturnItemCollectionMetrics": "",
        "ClientRequestToken": ""
    });

    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 '{
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TransactItems": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "ClientRequestToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TransactItems": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "ClientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.TransactWriteItems")! 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=DynamoDB_20120810.UntagResource");

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  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:ResourceArn ""
                                                                                                        :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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=DynamoDB_20120810.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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=DynamoDB_20120810.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "ResourceArn": "",
  "TagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource")
  .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=DynamoDB_20120810.UntagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  TagKeys: ''
});

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=DynamoDB_20120810.UntagResource');
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=DynamoDB_20120810.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

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=DynamoDB_20120810.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource")
  .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({ResourceArn: '', TagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', TagKeys: ''},
  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=DynamoDB_20120810.UntagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  TagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', TagKeys: ''}
};

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=DynamoDB_20120810.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","TagKeys":""}'
};

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 = @{ @"ResourceArn": @"",
                              @"TagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource"]
                                                       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=DynamoDB_20120810.UntagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource",
  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([
    'ResourceArn' => '',
    'TagKeys' => ''
  ]),
  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=DynamoDB_20120810.UntagResource', [
  'body' => '{
  "ResourceArn": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'TagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource');
$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=DynamoDB_20120810.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "TagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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=DynamoDB_20120810.UntagResource"

payload = {
    "ResourceArn": "",
    "TagKeys": ""
}
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=DynamoDB_20120810.UntagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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=DynamoDB_20120810.UntagResource")

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  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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  \"ResourceArn\": \"\",\n  \"TagKeys\": \"\"\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=DynamoDB_20120810.UntagResource";

    let payload = json!({
        "ResourceArn": "",
        "TagKeys": ""
    });

    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 '{
  "ResourceArn": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceArn": "",\n  "TagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "TagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UntagResource")! 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=DynamoDB_20120810.UpdateContinuousBackups");

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  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:TableName ""
                                                                                                                  :PointInTimeRecoverySpecification ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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=DynamoDB_20120810.UpdateContinuousBackups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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=DynamoDB_20120810.UpdateContinuousBackups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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: 63

{
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups")
  .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=DynamoDB_20120810.UpdateContinuousBackups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  PointInTimeRecoverySpecification: ''
});

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=DynamoDB_20120810.UpdateContinuousBackups');
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=DynamoDB_20120810.UpdateContinuousBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', PointInTimeRecoverySpecification: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","PointInTimeRecoverySpecification":""}'
};

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=DynamoDB_20120810.UpdateContinuousBackups',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "PointInTimeRecoverySpecification": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups")
  .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({TableName: '', PointInTimeRecoverySpecification: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: '', PointInTimeRecoverySpecification: ''},
  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=DynamoDB_20120810.UpdateContinuousBackups');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  PointInTimeRecoverySpecification: ''
});

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=DynamoDB_20120810.UpdateContinuousBackups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', PointInTimeRecoverySpecification: ''}
};

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=DynamoDB_20120810.UpdateContinuousBackups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","PointInTimeRecoverySpecification":""}'
};

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 = @{ @"TableName": @"",
                              @"PointInTimeRecoverySpecification": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups"]
                                                       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=DynamoDB_20120810.UpdateContinuousBackups" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups",
  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([
    'TableName' => '',
    'PointInTimeRecoverySpecification' => ''
  ]),
  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=DynamoDB_20120810.UpdateContinuousBackups', [
  'body' => '{
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'PointInTimeRecoverySpecification' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'PointInTimeRecoverySpecification' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups');
$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=DynamoDB_20120810.UpdateContinuousBackups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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=DynamoDB_20120810.UpdateContinuousBackups"

payload = {
    "TableName": "",
    "PointInTimeRecoverySpecification": ""
}
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=DynamoDB_20120810.UpdateContinuousBackups"

payload <- "{\n  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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=DynamoDB_20120810.UpdateContinuousBackups")

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  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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  \"TableName\": \"\",\n  \"PointInTimeRecoverySpecification\": \"\"\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=DynamoDB_20120810.UpdateContinuousBackups";

    let payload = json!({
        "TableName": "",
        "PointInTimeRecoverySpecification": ""
    });

    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 '{
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "PointInTimeRecoverySpecification": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "PointInTimeRecoverySpecification": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContinuousBackups")! 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=DynamoDB_20120810.UpdateContributorInsights");

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:TableName ""
                                                                                                                    :IndexName ""
                                                                                                                    :ContributorInsightsAction ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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=DynamoDB_20120810.UpdateContributorInsights"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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=DynamoDB_20120810.UpdateContributorInsights");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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: 75

{
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights")
  .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=DynamoDB_20120810.UpdateContributorInsights")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  IndexName: '',
  ContributorInsightsAction: ''
});

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=DynamoDB_20120810.UpdateContributorInsights');
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=DynamoDB_20120810.UpdateContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', IndexName: '', ContributorInsightsAction: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","ContributorInsightsAction":""}'
};

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=DynamoDB_20120810.UpdateContributorInsights',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "IndexName": "",\n  "ContributorInsightsAction": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights")
  .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({TableName: '', IndexName: '', ContributorInsightsAction: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TableName: '', IndexName: '', ContributorInsightsAction: ''},
  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=DynamoDB_20120810.UpdateContributorInsights');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  IndexName: '',
  ContributorInsightsAction: ''
});

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=DynamoDB_20120810.UpdateContributorInsights',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TableName: '', IndexName: '', ContributorInsightsAction: ''}
};

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=DynamoDB_20120810.UpdateContributorInsights';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","IndexName":"","ContributorInsightsAction":""}'
};

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 = @{ @"TableName": @"",
                              @"IndexName": @"",
                              @"ContributorInsightsAction": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights"]
                                                       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=DynamoDB_20120810.UpdateContributorInsights" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights",
  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([
    'TableName' => '',
    'IndexName' => '',
    'ContributorInsightsAction' => ''
  ]),
  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=DynamoDB_20120810.UpdateContributorInsights', [
  'body' => '{
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'ContributorInsightsAction' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'IndexName' => '',
  'ContributorInsightsAction' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights');
$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=DynamoDB_20120810.UpdateContributorInsights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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=DynamoDB_20120810.UpdateContributorInsights"

payload = {
    "TableName": "",
    "IndexName": "",
    "ContributorInsightsAction": ""
}
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=DynamoDB_20120810.UpdateContributorInsights"

payload <- "{\n  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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=DynamoDB_20120810.UpdateContributorInsights")

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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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  \"TableName\": \"\",\n  \"IndexName\": \"\",\n  \"ContributorInsightsAction\": \"\"\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=DynamoDB_20120810.UpdateContributorInsights";

    let payload = json!({
        "TableName": "",
        "IndexName": "",
        "ContributorInsightsAction": ""
    });

    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 '{
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "IndexName": "",\n  "ContributorInsightsAction": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "IndexName": "",
  "ContributorInsightsAction": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateContributorInsights")! 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=DynamoDB_20120810.UpdateGlobalTable");

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  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:GlobalTableName ""
                                                                                                            :ReplicaUpdates ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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=DynamoDB_20120810.UpdateGlobalTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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=DynamoDB_20120810.UpdateGlobalTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable"

	payload := strings.NewReader("{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "GlobalTableName": "",
  "ReplicaUpdates": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable")
  .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=DynamoDB_20120810.UpdateGlobalTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GlobalTableName: '',
  ReplicaUpdates: ''
});

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=DynamoDB_20120810.UpdateGlobalTable');
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=DynamoDB_20120810.UpdateGlobalTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GlobalTableName: '', ReplicaUpdates: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GlobalTableName":"","ReplicaUpdates":""}'
};

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=DynamoDB_20120810.UpdateGlobalTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GlobalTableName": "",\n  "ReplicaUpdates": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable")
  .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({GlobalTableName: '', ReplicaUpdates: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GlobalTableName: '', ReplicaUpdates: ''},
  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=DynamoDB_20120810.UpdateGlobalTable');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GlobalTableName: '',
  ReplicaUpdates: ''
});

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=DynamoDB_20120810.UpdateGlobalTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GlobalTableName: '', ReplicaUpdates: ''}
};

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=DynamoDB_20120810.UpdateGlobalTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GlobalTableName":"","ReplicaUpdates":""}'
};

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 = @{ @"GlobalTableName": @"",
                              @"ReplicaUpdates": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable"]
                                                       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=DynamoDB_20120810.UpdateGlobalTable" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable",
  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([
    'GlobalTableName' => '',
    'ReplicaUpdates' => ''
  ]),
  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=DynamoDB_20120810.UpdateGlobalTable', [
  'body' => '{
  "GlobalTableName": "",
  "ReplicaUpdates": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GlobalTableName' => '',
  'ReplicaUpdates' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GlobalTableName' => '',
  'ReplicaUpdates' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable');
$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=DynamoDB_20120810.UpdateGlobalTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalTableName": "",
  "ReplicaUpdates": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalTableName": "",
  "ReplicaUpdates": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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=DynamoDB_20120810.UpdateGlobalTable"

payload = {
    "GlobalTableName": "",
    "ReplicaUpdates": ""
}
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=DynamoDB_20120810.UpdateGlobalTable"

payload <- "{\n  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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=DynamoDB_20120810.UpdateGlobalTable")

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  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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  \"GlobalTableName\": \"\",\n  \"ReplicaUpdates\": \"\"\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=DynamoDB_20120810.UpdateGlobalTable";

    let payload = json!({
        "GlobalTableName": "",
        "ReplicaUpdates": ""
    });

    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 '{
  "GlobalTableName": "",
  "ReplicaUpdates": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GlobalTableName": "",\n  "ReplicaUpdates": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GlobalTableName": "",
  "ReplicaUpdates": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTable")! 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=DynamoDB_20120810.UpdateGlobalTableSettings");

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  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:GlobalTableName ""
                                                                                                                    :GlobalTableBillingMode ""
                                                                                                                    :GlobalTableProvisionedWriteCapacityUnits ""
                                                                                                                    :GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate ""
                                                                                                                    :GlobalTableGlobalSecondaryIndexSettingsUpdate ""
                                                                                                                    :ReplicaSettingsUpdate ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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=DynamoDB_20120810.UpdateGlobalTableSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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=DynamoDB_20120810.UpdateGlobalTableSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings"

	payload := strings.NewReader("{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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

{
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings")
  .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=DynamoDB_20120810.UpdateGlobalTableSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GlobalTableName: '',
  GlobalTableBillingMode: '',
  GlobalTableProvisionedWriteCapacityUnits: '',
  GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
  GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
  ReplicaSettingsUpdate: ''
});

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=DynamoDB_20120810.UpdateGlobalTableSettings');
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=DynamoDB_20120810.UpdateGlobalTableSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GlobalTableName: '',
    GlobalTableBillingMode: '',
    GlobalTableProvisionedWriteCapacityUnits: '',
    GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
    GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
    ReplicaSettingsUpdate: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GlobalTableName":"","GlobalTableBillingMode":"","GlobalTableProvisionedWriteCapacityUnits":"","GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate":"","GlobalTableGlobalSecondaryIndexSettingsUpdate":"","ReplicaSettingsUpdate":""}'
};

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=DynamoDB_20120810.UpdateGlobalTableSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GlobalTableName": "",\n  "GlobalTableBillingMode": "",\n  "GlobalTableProvisionedWriteCapacityUnits": "",\n  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",\n  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",\n  "ReplicaSettingsUpdate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings")
  .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({
  GlobalTableName: '',
  GlobalTableBillingMode: '',
  GlobalTableProvisionedWriteCapacityUnits: '',
  GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
  GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
  ReplicaSettingsUpdate: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GlobalTableName: '',
    GlobalTableBillingMode: '',
    GlobalTableProvisionedWriteCapacityUnits: '',
    GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
    GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
    ReplicaSettingsUpdate: ''
  },
  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=DynamoDB_20120810.UpdateGlobalTableSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GlobalTableName: '',
  GlobalTableBillingMode: '',
  GlobalTableProvisionedWriteCapacityUnits: '',
  GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
  GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
  ReplicaSettingsUpdate: ''
});

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=DynamoDB_20120810.UpdateGlobalTableSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GlobalTableName: '',
    GlobalTableBillingMode: '',
    GlobalTableProvisionedWriteCapacityUnits: '',
    GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate: '',
    GlobalTableGlobalSecondaryIndexSettingsUpdate: '',
    ReplicaSettingsUpdate: ''
  }
};

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=DynamoDB_20120810.UpdateGlobalTableSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GlobalTableName":"","GlobalTableBillingMode":"","GlobalTableProvisionedWriteCapacityUnits":"","GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate":"","GlobalTableGlobalSecondaryIndexSettingsUpdate":"","ReplicaSettingsUpdate":""}'
};

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 = @{ @"GlobalTableName": @"",
                              @"GlobalTableBillingMode": @"",
                              @"GlobalTableProvisionedWriteCapacityUnits": @"",
                              @"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": @"",
                              @"GlobalTableGlobalSecondaryIndexSettingsUpdate": @"",
                              @"ReplicaSettingsUpdate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings"]
                                                       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=DynamoDB_20120810.UpdateGlobalTableSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings",
  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([
    'GlobalTableName' => '',
    'GlobalTableBillingMode' => '',
    'GlobalTableProvisionedWriteCapacityUnits' => '',
    'GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate' => '',
    'GlobalTableGlobalSecondaryIndexSettingsUpdate' => '',
    'ReplicaSettingsUpdate' => ''
  ]),
  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=DynamoDB_20120810.UpdateGlobalTableSettings', [
  'body' => '{
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GlobalTableName' => '',
  'GlobalTableBillingMode' => '',
  'GlobalTableProvisionedWriteCapacityUnits' => '',
  'GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate' => '',
  'GlobalTableGlobalSecondaryIndexSettingsUpdate' => '',
  'ReplicaSettingsUpdate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GlobalTableName' => '',
  'GlobalTableBillingMode' => '',
  'GlobalTableProvisionedWriteCapacityUnits' => '',
  'GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate' => '',
  'GlobalTableGlobalSecondaryIndexSettingsUpdate' => '',
  'ReplicaSettingsUpdate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings');
$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=DynamoDB_20120810.UpdateGlobalTableSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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=DynamoDB_20120810.UpdateGlobalTableSettings"

payload = {
    "GlobalTableName": "",
    "GlobalTableBillingMode": "",
    "GlobalTableProvisionedWriteCapacityUnits": "",
    "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
    "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
    "ReplicaSettingsUpdate": ""
}
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=DynamoDB_20120810.UpdateGlobalTableSettings"

payload <- "{\n  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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=DynamoDB_20120810.UpdateGlobalTableSettings")

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  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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  \"GlobalTableName\": \"\",\n  \"GlobalTableBillingMode\": \"\",\n  \"GlobalTableProvisionedWriteCapacityUnits\": \"\",\n  \"GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate\": \"\",\n  \"GlobalTableGlobalSecondaryIndexSettingsUpdate\": \"\",\n  \"ReplicaSettingsUpdate\": \"\"\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=DynamoDB_20120810.UpdateGlobalTableSettings";

    let payload = json!({
        "GlobalTableName": "",
        "GlobalTableBillingMode": "",
        "GlobalTableProvisionedWriteCapacityUnits": "",
        "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
        "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
        "ReplicaSettingsUpdate": ""
    });

    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 '{
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GlobalTableName": "",\n  "GlobalTableBillingMode": "",\n  "GlobalTableProvisionedWriteCapacityUnits": "",\n  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",\n  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",\n  "ReplicaSettingsUpdate": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GlobalTableName": "",
  "GlobalTableBillingMode": "",
  "GlobalTableProvisionedWriteCapacityUnits": "",
  "GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate": "",
  "GlobalTableGlobalSecondaryIndexSettingsUpdate": "",
  "ReplicaSettingsUpdate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateGlobalTableSettings")! 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=DynamoDB_20120810.UpdateItem");

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:TableName ""
                                                                                                     :Key ""
                                                                                                     :AttributeUpdates ""
                                                                                                     :Expected ""
                                                                                                     :ConditionalOperator ""
                                                                                                     :ReturnValues ""
                                                                                                     :ReturnConsumedCapacity ""
                                                                                                     :ReturnItemCollectionMetrics ""
                                                                                                     :UpdateExpression ""
                                                                                                     :ConditionExpression ""
                                                                                                     :ExpressionAttributeNames ""
                                                                                                     :ExpressionAttributeValues ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.UpdateItem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.UpdateItem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem"

	payload := strings.NewReader("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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: 322

{
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem")
  .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=DynamoDB_20120810.UpdateItem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TableName: '',
  Key: '',
  AttributeUpdates: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  UpdateExpression: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.UpdateItem');
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=DynamoDB_20120810.UpdateItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    AttributeUpdates: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    UpdateExpression: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","AttributeUpdates":"","Expected":"","ConditionalOperator":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","UpdateExpression":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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=DynamoDB_20120810.UpdateItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TableName": "",\n  "Key": "",\n  "AttributeUpdates": "",\n  "Expected": "",\n  "ConditionalOperator": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "UpdateExpression": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem")
  .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({
  TableName: '',
  Key: '',
  AttributeUpdates: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  UpdateExpression: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TableName: '',
    Key: '',
    AttributeUpdates: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    UpdateExpression: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  },
  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=DynamoDB_20120810.UpdateItem');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TableName: '',
  Key: '',
  AttributeUpdates: '',
  Expected: '',
  ConditionalOperator: '',
  ReturnValues: '',
  ReturnConsumedCapacity: '',
  ReturnItemCollectionMetrics: '',
  UpdateExpression: '',
  ConditionExpression: '',
  ExpressionAttributeNames: '',
  ExpressionAttributeValues: ''
});

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=DynamoDB_20120810.UpdateItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TableName: '',
    Key: '',
    AttributeUpdates: '',
    Expected: '',
    ConditionalOperator: '',
    ReturnValues: '',
    ReturnConsumedCapacity: '',
    ReturnItemCollectionMetrics: '',
    UpdateExpression: '',
    ConditionExpression: '',
    ExpressionAttributeNames: '',
    ExpressionAttributeValues: ''
  }
};

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=DynamoDB_20120810.UpdateItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TableName":"","Key":"","AttributeUpdates":"","Expected":"","ConditionalOperator":"","ReturnValues":"","ReturnConsumedCapacity":"","ReturnItemCollectionMetrics":"","UpdateExpression":"","ConditionExpression":"","ExpressionAttributeNames":"","ExpressionAttributeValues":""}'
};

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 = @{ @"TableName": @"",
                              @"Key": @"",
                              @"AttributeUpdates": @"",
                              @"Expected": @"",
                              @"ConditionalOperator": @"",
                              @"ReturnValues": @"",
                              @"ReturnConsumedCapacity": @"",
                              @"ReturnItemCollectionMetrics": @"",
                              @"UpdateExpression": @"",
                              @"ConditionExpression": @"",
                              @"ExpressionAttributeNames": @"",
                              @"ExpressionAttributeValues": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem"]
                                                       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=DynamoDB_20120810.UpdateItem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem",
  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([
    'TableName' => '',
    'Key' => '',
    'AttributeUpdates' => '',
    'Expected' => '',
    'ConditionalOperator' => '',
    'ReturnValues' => '',
    'ReturnConsumedCapacity' => '',
    'ReturnItemCollectionMetrics' => '',
    'UpdateExpression' => '',
    'ConditionExpression' => '',
    'ExpressionAttributeNames' => '',
    'ExpressionAttributeValues' => ''
  ]),
  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=DynamoDB_20120810.UpdateItem', [
  'body' => '{
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TableName' => '',
  'Key' => '',
  'AttributeUpdates' => '',
  'Expected' => '',
  'ConditionalOperator' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'UpdateExpression' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TableName' => '',
  'Key' => '',
  'AttributeUpdates' => '',
  'Expected' => '',
  'ConditionalOperator' => '',
  'ReturnValues' => '',
  'ReturnConsumedCapacity' => '',
  'ReturnItemCollectionMetrics' => '',
  'UpdateExpression' => '',
  'ConditionExpression' => '',
  'ExpressionAttributeNames' => '',
  'ExpressionAttributeValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem');
$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=DynamoDB_20120810.UpdateItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.UpdateItem"

payload = {
    "TableName": "",
    "Key": "",
    "AttributeUpdates": "",
    "Expected": "",
    "ConditionalOperator": "",
    "ReturnValues": "",
    "ReturnConsumedCapacity": "",
    "ReturnItemCollectionMetrics": "",
    "UpdateExpression": "",
    "ConditionExpression": "",
    "ExpressionAttributeNames": "",
    "ExpressionAttributeValues": ""
}
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=DynamoDB_20120810.UpdateItem"

payload <- "{\n  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.UpdateItem")

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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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  \"TableName\": \"\",\n  \"Key\": \"\",\n  \"AttributeUpdates\": \"\",\n  \"Expected\": \"\",\n  \"ConditionalOperator\": \"\",\n  \"ReturnValues\": \"\",\n  \"ReturnConsumedCapacity\": \"\",\n  \"ReturnItemCollectionMetrics\": \"\",\n  \"UpdateExpression\": \"\",\n  \"ConditionExpression\": \"\",\n  \"ExpressionAttributeNames\": \"\",\n  \"ExpressionAttributeValues\": \"\"\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=DynamoDB_20120810.UpdateItem";

    let payload = json!({
        "TableName": "",
        "Key": "",
        "AttributeUpdates": "",
        "Expected": "",
        "ConditionalOperator": "",
        "ReturnValues": "",
        "ReturnConsumedCapacity": "",
        "ReturnItemCollectionMetrics": "",
        "UpdateExpression": "",
        "ConditionExpression": "",
        "ExpressionAttributeNames": "",
        "ExpressionAttributeValues": ""
    });

    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 '{
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TableName": "",\n  "Key": "",\n  "AttributeUpdates": "",\n  "Expected": "",\n  "ConditionalOperator": "",\n  "ReturnValues": "",\n  "ReturnConsumedCapacity": "",\n  "ReturnItemCollectionMetrics": "",\n  "UpdateExpression": "",\n  "ConditionExpression": "",\n  "ExpressionAttributeNames": "",\n  "ExpressionAttributeValues": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TableName": "",
  "Key": "",
  "AttributeUpdates": "",
  "Expected": "",
  "ConditionalOperator": "",
  "ReturnValues": "",
  "ReturnConsumedCapacity": "",
  "ReturnItemCollectionMetrics": "",
  "UpdateExpression": "",
  "ConditionExpression": "",
  "ExpressionAttributeNames": "",
  "ExpressionAttributeValues": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateItem")! 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=DynamoDB_20120810.UpdateTable");

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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:AttributeDefinitions ""
                                                                                                      :TableName ""
                                                                                                      :BillingMode ""
                                                                                                      :ProvisionedThroughput ""
                                                                                                      :GlobalSecondaryIndexUpdates ""
                                                                                                      :StreamSpecification ""
                                                                                                      :SSESpecification ""
                                                                                                      :ReplicaUpdates ""
                                                                                                      :TableClass ""
                                                                                                      :DeletionProtectionEnabled ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.UpdateTable"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.UpdateTable");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable"

	payload := strings.NewReader("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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: 274

{
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable")
  .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=DynamoDB_20120810.UpdateTable")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AttributeDefinitions: '',
  TableName: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  GlobalSecondaryIndexUpdates: '',
  StreamSpecification: '',
  SSESpecification: '',
  ReplicaUpdates: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
});

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=DynamoDB_20120810.UpdateTable');
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=DynamoDB_20120810.UpdateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AttributeDefinitions: '',
    TableName: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    GlobalSecondaryIndexUpdates: '',
    StreamSpecification: '',
    SSESpecification: '',
    ReplicaUpdates: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AttributeDefinitions":"","TableName":"","BillingMode":"","ProvisionedThroughput":"","GlobalSecondaryIndexUpdates":"","StreamSpecification":"","SSESpecification":"","ReplicaUpdates":"","TableClass":"","DeletionProtectionEnabled":""}'
};

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=DynamoDB_20120810.UpdateTable',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AttributeDefinitions": "",\n  "TableName": "",\n  "BillingMode": "",\n  "ProvisionedThroughput": "",\n  "GlobalSecondaryIndexUpdates": "",\n  "StreamSpecification": "",\n  "SSESpecification": "",\n  "ReplicaUpdates": "",\n  "TableClass": "",\n  "DeletionProtectionEnabled": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable")
  .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({
  AttributeDefinitions: '',
  TableName: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  GlobalSecondaryIndexUpdates: '',
  StreamSpecification: '',
  SSESpecification: '',
  ReplicaUpdates: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AttributeDefinitions: '',
    TableName: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    GlobalSecondaryIndexUpdates: '',
    StreamSpecification: '',
    SSESpecification: '',
    ReplicaUpdates: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  },
  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=DynamoDB_20120810.UpdateTable');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AttributeDefinitions: '',
  TableName: '',
  BillingMode: '',
  ProvisionedThroughput: '',
  GlobalSecondaryIndexUpdates: '',
  StreamSpecification: '',
  SSESpecification: '',
  ReplicaUpdates: '',
  TableClass: '',
  DeletionProtectionEnabled: ''
});

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=DynamoDB_20120810.UpdateTable',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AttributeDefinitions: '',
    TableName: '',
    BillingMode: '',
    ProvisionedThroughput: '',
    GlobalSecondaryIndexUpdates: '',
    StreamSpecification: '',
    SSESpecification: '',
    ReplicaUpdates: '',
    TableClass: '',
    DeletionProtectionEnabled: ''
  }
};

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=DynamoDB_20120810.UpdateTable';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AttributeDefinitions":"","TableName":"","BillingMode":"","ProvisionedThroughput":"","GlobalSecondaryIndexUpdates":"","StreamSpecification":"","SSESpecification":"","ReplicaUpdates":"","TableClass":"","DeletionProtectionEnabled":""}'
};

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 = @{ @"AttributeDefinitions": @"",
                              @"TableName": @"",
                              @"BillingMode": @"",
                              @"ProvisionedThroughput": @"",
                              @"GlobalSecondaryIndexUpdates": @"",
                              @"StreamSpecification": @"",
                              @"SSESpecification": @"",
                              @"ReplicaUpdates": @"",
                              @"TableClass": @"",
                              @"DeletionProtectionEnabled": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable"]
                                                       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=DynamoDB_20120810.UpdateTable" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable",
  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([
    'AttributeDefinitions' => '',
    'TableName' => '',
    'BillingMode' => '',
    'ProvisionedThroughput' => '',
    'GlobalSecondaryIndexUpdates' => '',
    'StreamSpecification' => '',
    'SSESpecification' => '',
    'ReplicaUpdates' => '',
    'TableClass' => '',
    'DeletionProtectionEnabled' => ''
  ]),
  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=DynamoDB_20120810.UpdateTable', [
  'body' => '{
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AttributeDefinitions' => '',
  'TableName' => '',
  'BillingMode' => '',
  'ProvisionedThroughput' => '',
  'GlobalSecondaryIndexUpdates' => '',
  'StreamSpecification' => '',
  'SSESpecification' => '',
  'ReplicaUpdates' => '',
  'TableClass' => '',
  'DeletionProtectionEnabled' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AttributeDefinitions' => '',
  'TableName' => '',
  'BillingMode' => '',
  'ProvisionedThroughput' => '',
  'GlobalSecondaryIndexUpdates' => '',
  'StreamSpecification' => '',
  'SSESpecification' => '',
  'ReplicaUpdates' => '',
  'TableClass' => '',
  'DeletionProtectionEnabled' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable');
$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=DynamoDB_20120810.UpdateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.UpdateTable"

payload = {
    "AttributeDefinitions": "",
    "TableName": "",
    "BillingMode": "",
    "ProvisionedThroughput": "",
    "GlobalSecondaryIndexUpdates": "",
    "StreamSpecification": "",
    "SSESpecification": "",
    "ReplicaUpdates": "",
    "TableClass": "",
    "DeletionProtectionEnabled": ""
}
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=DynamoDB_20120810.UpdateTable"

payload <- "{\n  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.UpdateTable")

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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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  \"AttributeDefinitions\": \"\",\n  \"TableName\": \"\",\n  \"BillingMode\": \"\",\n  \"ProvisionedThroughput\": \"\",\n  \"GlobalSecondaryIndexUpdates\": \"\",\n  \"StreamSpecification\": \"\",\n  \"SSESpecification\": \"\",\n  \"ReplicaUpdates\": \"\",\n  \"TableClass\": \"\",\n  \"DeletionProtectionEnabled\": \"\"\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=DynamoDB_20120810.UpdateTable";

    let payload = json!({
        "AttributeDefinitions": "",
        "TableName": "",
        "BillingMode": "",
        "ProvisionedThroughput": "",
        "GlobalSecondaryIndexUpdates": "",
        "StreamSpecification": "",
        "SSESpecification": "",
        "ReplicaUpdates": "",
        "TableClass": "",
        "DeletionProtectionEnabled": ""
    });

    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 '{
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AttributeDefinitions": "",\n  "TableName": "",\n  "BillingMode": "",\n  "ProvisionedThroughput": "",\n  "GlobalSecondaryIndexUpdates": "",\n  "StreamSpecification": "",\n  "SSESpecification": "",\n  "ReplicaUpdates": "",\n  "TableClass": "",\n  "DeletionProtectionEnabled": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AttributeDefinitions": "",
  "TableName": "",
  "BillingMode": "",
  "ProvisionedThroughput": "",
  "GlobalSecondaryIndexUpdates": "",
  "StreamSpecification": "",
  "SSESpecification": "",
  "ReplicaUpdates": "",
  "TableClass": "",
  "DeletionProtectionEnabled": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=DynamoDB_20120810.UpdateTable")! 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()