CURL *hnd = curl_easy_init();

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

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=AmazonDMSv20160101.AddTagsToResource" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:ResourceArn ""
                                                                                                             :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.AddTagsToResource"
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=AmazonDMSv20160101.AddTagsToResource"),
    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=AmazonDMSv20160101.AddTagsToResource");
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=AmazonDMSv20160101.AddTagsToResource"

	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=AmazonDMSv20160101.AddTagsToResource")
  .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=AmazonDMSv20160101.AddTagsToResource"))
    .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=AmazonDMSv20160101.AddTagsToResource")
  .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=AmazonDMSv20160101.AddTagsToResource")
  .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=AmazonDMSv20160101.AddTagsToResource');
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=AmazonDMSv20160101.AddTagsToResource',
  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=AmazonDMSv20160101.AddTagsToResource';
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=AmazonDMSv20160101.AddTagsToResource',
  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=AmazonDMSv20160101.AddTagsToResource")
  .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=AmazonDMSv20160101.AddTagsToResource',
  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=AmazonDMSv20160101.AddTagsToResource');

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=AmazonDMSv20160101.AddTagsToResource',
  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=AmazonDMSv20160101.AddTagsToResource';
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=AmazonDMSv20160101.AddTagsToResource"]
                                                       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=AmazonDMSv20160101.AddTagsToResource" 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=AmazonDMSv20160101.AddTagsToResource",
  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=AmazonDMSv20160101.AddTagsToResource', [
  'body' => '{
  "ResourceArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.AddTagsToResource');
$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=AmazonDMSv20160101.AddTagsToResource');
$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=AmazonDMSv20160101.AddTagsToResource' -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=AmazonDMSv20160101.AddTagsToResource' -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=AmazonDMSv20160101.AddTagsToResource"

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=AmazonDMSv20160101.AddTagsToResource"

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=AmazonDMSv20160101.AddTagsToResource")

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=AmazonDMSv20160101.AddTagsToResource";

    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=AmazonDMSv20160101.AddTagsToResource' \
  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=AmazonDMSv20160101.AddTagsToResource'

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=AmazonDMSv20160101.AddTagsToResource")! 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=AmazonDMSv20160101.ApplyPendingMaintenanceAction");

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  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ApplyPendingMaintenanceAction" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:ReplicationInstanceArn ""
                                                                                                                         :ApplyAction ""
                                                                                                                         :OptInType ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ApplyPendingMaintenanceAction"

	payload := strings.NewReader("{\n  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\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: 74

{
  "ReplicationInstanceArn": "",
  "ApplyAction": "",
  "OptInType": ""
}

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

client.close();

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

const data = JSON.stringify({
  ReplicationInstanceArn: '',
  ApplyAction: '',
  OptInType: ''
});

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=AmazonDMSv20160101.ApplyPendingMaintenanceAction');
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=AmazonDMSv20160101.ApplyPendingMaintenanceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', ApplyAction: '', OptInType: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ApplyPendingMaintenanceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","ApplyAction":"","OptInType":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ReplicationInstanceArn: '',
  ApplyAction: '',
  OptInType: ''
});

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=AmazonDMSv20160101.ApplyPendingMaintenanceAction',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', ApplyAction: '', OptInType: ''}
};

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=AmazonDMSv20160101.ApplyPendingMaintenanceAction';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","ApplyAction":"","OptInType":""}'
};

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 = @{ @"ReplicationInstanceArn": @"",
                              @"ApplyAction": @"",
                              @"OptInType": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationInstanceArn' => '',
  'ApplyAction' => '',
  'OptInType' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\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=AmazonDMSv20160101.ApplyPendingMaintenanceAction"

payload = {
    "ReplicationInstanceArn": "",
    "ApplyAction": "",
    "OptInType": ""
}
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=AmazonDMSv20160101.ApplyPendingMaintenanceAction"

payload <- "{\n  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\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=AmazonDMSv20160101.ApplyPendingMaintenanceAction")

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  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\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  \"ReplicationInstanceArn\": \"\",\n  \"ApplyAction\": \"\",\n  \"OptInType\": \"\"\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=AmazonDMSv20160101.ApplyPendingMaintenanceAction";

    let payload = json!({
        "ReplicationInstanceArn": "",
        "ApplyAction": "",
        "OptInType": ""
    });

    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 '{
  "ReplicationInstanceArn": "",
  "ApplyAction": "",
  "OptInType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ApplyPendingMaintenanceAction' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationInstanceArn": "",\n  "ApplyAction": "",\n  "OptInType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ApplyPendingMaintenanceAction'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.BatchStartRecommendations"

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

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

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

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

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

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

}

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

{
  "Data": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Data\": \"\"\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=AmazonDMSv20160101.BatchStartRecommendations"

payload = { "Data": "" }
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=AmazonDMSv20160101.BatchStartRecommendations"

payload <- "{\n  \"Data\": \"\"\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=AmazonDMSv20160101.BatchStartRecommendations")

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  \"Data\": \"\"\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  \"Data\": \"\"\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=AmazonDMSv20160101.BatchStartRecommendations";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CancelReplicationTaskAssessmentRun"

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

{
  "ReplicationTaskAssessmentRunArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.CancelReplicationTaskAssessmentRun"

payload = { "ReplicationTaskAssessmentRunArn": "" }
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=AmazonDMSv20160101.CancelReplicationTaskAssessmentRun"

payload <- "{\n  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.CancelReplicationTaskAssessmentRun")

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  \"ReplicationTaskAssessmentRunArn\": \"\"\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  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.CancelReplicationTaskAssessmentRun";

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

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

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

import Foundation

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

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

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

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  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:EndpointIdentifier ""
                                                                                                          :EndpointType ""
                                                                                                          :EngineName ""
                                                                                                          :Username ""
                                                                                                          :Password ""
                                                                                                          :ServerName ""
                                                                                                          :Port ""
                                                                                                          :DatabaseName ""
                                                                                                          :ExtraConnectionAttributes ""
                                                                                                          :KmsKeyId ""
                                                                                                          :Tags ""
                                                                                                          :CertificateArn ""
                                                                                                          :SslMode ""
                                                                                                          :ServiceAccessRoleArn ""
                                                                                                          :ExternalTableDefinition ""
                                                                                                          :DynamoDbSettings ""
                                                                                                          :S3Settings ""
                                                                                                          :DmsTransferSettings ""
                                                                                                          :MongoDbSettings ""
                                                                                                          :KinesisSettings ""
                                                                                                          :KafkaSettings ""
                                                                                                          :ElasticsearchSettings ""
                                                                                                          :NeptuneSettings ""
                                                                                                          :RedshiftSettings {:AcceptAnyDate ""
                                                                                                                             :AfterConnectScript ""
                                                                                                                             :BucketFolder ""
                                                                                                                             :BucketName ""
                                                                                                                             :CaseSensitiveNames ""
                                                                                                                             :CompUpdate ""
                                                                                                                             :ConnectionTimeout ""
                                                                                                                             :DatabaseName ""
                                                                                                                             :DateFormat ""
                                                                                                                             :EmptyAsNull ""
                                                                                                                             :EncryptionMode ""
                                                                                                                             :ExplicitIds ""
                                                                                                                             :FileTransferUploadStreams ""
                                                                                                                             :LoadTimeout ""
                                                                                                                             :MaxFileSize ""
                                                                                                                             :Password ""
                                                                                                                             :Port ""
                                                                                                                             :RemoveQuotes ""
                                                                                                                             :ReplaceInvalidChars ""
                                                                                                                             :ReplaceChars ""
                                                                                                                             :ServerName ""
                                                                                                                             :ServiceAccessRoleArn ""
                                                                                                                             :ServerSideEncryptionKmsKeyId ""
                                                                                                                             :TimeFormat ""
                                                                                                                             :TrimBlanks ""
                                                                                                                             :TruncateColumns ""
                                                                                                                             :Username ""
                                                                                                                             :WriteBufferSize ""
                                                                                                                             :SecretsManagerAccessRoleArn ""
                                                                                                                             :SecretsManagerSecretId ""
                                                                                                                             :MapBooleanAsBoolean ""}
                                                                                                          :PostgreSQLSettings ""
                                                                                                          :MySQLSettings ""
                                                                                                          :OracleSettings ""
                                                                                                          :SybaseSettings ""
                                                                                                          :MicrosoftSQLServerSettings ""
                                                                                                          :IBMDb2Settings ""
                                                                                                          :ResourceIdentifier ""
                                                                                                          :DocDbSettings {:Username ""
                                                                                                                          :Password ""
                                                                                                                          :ServerName ""
                                                                                                                          :Port ""
                                                                                                                          :DatabaseName ""
                                                                                                                          :NestingLevel ""
                                                                                                                          :ExtractDocId ""
                                                                                                                          :DocsToInvestigate ""
                                                                                                                          :KmsKeyId ""
                                                                                                                          :SecretsManagerAccessRoleArn ""
                                                                                                                          :SecretsManagerSecretId ""}
                                                                                                          :RedisSettings ""
                                                                                                          :GcpMySQLSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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=AmazonDMSv20160101.CreateEndpoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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=AmazonDMSv20160101.CreateEndpoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint"

	payload := strings.NewReader("{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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: 1914

{
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": {
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  },
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": {
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  },
  "RedisSettings": "",
  "GcpMySQLSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint")
  .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=AmazonDMSv20160101.CreateEndpoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointIdentifier: '',
  EndpointType: '',
  EngineName: '',
  Username: '',
  Password: '',
  ServerName: '',
  Port: '',
  DatabaseName: '',
  ExtraConnectionAttributes: '',
  KmsKeyId: '',
  Tags: '',
  CertificateArn: '',
  SslMode: '',
  ServiceAccessRoleArn: '',
  ExternalTableDefinition: '',
  DynamoDbSettings: '',
  S3Settings: '',
  DmsTransferSettings: '',
  MongoDbSettings: '',
  KinesisSettings: '',
  KafkaSettings: '',
  ElasticsearchSettings: '',
  NeptuneSettings: '',
  RedshiftSettings: {
    AcceptAnyDate: '',
    AfterConnectScript: '',
    BucketFolder: '',
    BucketName: '',
    CaseSensitiveNames: '',
    CompUpdate: '',
    ConnectionTimeout: '',
    DatabaseName: '',
    DateFormat: '',
    EmptyAsNull: '',
    EncryptionMode: '',
    ExplicitIds: '',
    FileTransferUploadStreams: '',
    LoadTimeout: '',
    MaxFileSize: '',
    Password: '',
    Port: '',
    RemoveQuotes: '',
    ReplaceInvalidChars: '',
    ReplaceChars: '',
    ServerName: '',
    ServiceAccessRoleArn: '',
    ServerSideEncryptionKmsKeyId: '',
    TimeFormat: '',
    TrimBlanks: '',
    TruncateColumns: '',
    Username: '',
    WriteBufferSize: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: '',
    MapBooleanAsBoolean: ''
  },
  PostgreSQLSettings: '',
  MySQLSettings: '',
  OracleSettings: '',
  SybaseSettings: '',
  MicrosoftSQLServerSettings: '',
  IBMDb2Settings: '',
  ResourceIdentifier: '',
  DocDbSettings: {
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    NestingLevel: '',
    ExtractDocId: '',
    DocsToInvestigate: '',
    KmsKeyId: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: ''
  },
  RedisSettings: '',
  GcpMySQLSettings: ''
});

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=AmazonDMSv20160101.CreateEndpoint');
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=AmazonDMSv20160101.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointIdentifier: '',
    EndpointType: '',
    EngineName: '',
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    ExtraConnectionAttributes: '',
    KmsKeyId: '',
    Tags: '',
    CertificateArn: '',
    SslMode: '',
    ServiceAccessRoleArn: '',
    ExternalTableDefinition: '',
    DynamoDbSettings: '',
    S3Settings: '',
    DmsTransferSettings: '',
    MongoDbSettings: '',
    KinesisSettings: '',
    KafkaSettings: '',
    ElasticsearchSettings: '',
    NeptuneSettings: '',
    RedshiftSettings: {
      AcceptAnyDate: '',
      AfterConnectScript: '',
      BucketFolder: '',
      BucketName: '',
      CaseSensitiveNames: '',
      CompUpdate: '',
      ConnectionTimeout: '',
      DatabaseName: '',
      DateFormat: '',
      EmptyAsNull: '',
      EncryptionMode: '',
      ExplicitIds: '',
      FileTransferUploadStreams: '',
      LoadTimeout: '',
      MaxFileSize: '',
      Password: '',
      Port: '',
      RemoveQuotes: '',
      ReplaceInvalidChars: '',
      ReplaceChars: '',
      ServerName: '',
      ServiceAccessRoleArn: '',
      ServerSideEncryptionKmsKeyId: '',
      TimeFormat: '',
      TrimBlanks: '',
      TruncateColumns: '',
      Username: '',
      WriteBufferSize: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: '',
      MapBooleanAsBoolean: ''
    },
    PostgreSQLSettings: '',
    MySQLSettings: '',
    OracleSettings: '',
    SybaseSettings: '',
    MicrosoftSQLServerSettings: '',
    IBMDb2Settings: '',
    ResourceIdentifier: '',
    DocDbSettings: {
      Username: '',
      Password: '',
      ServerName: '',
      Port: '',
      DatabaseName: '',
      NestingLevel: '',
      ExtractDocId: '',
      DocsToInvestigate: '',
      KmsKeyId: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: ''
    },
    RedisSettings: '',
    GcpMySQLSettings: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointIdentifier":"","EndpointType":"","EngineName":"","Username":"","Password":"","ServerName":"","Port":"","DatabaseName":"","ExtraConnectionAttributes":"","KmsKeyId":"","Tags":"","CertificateArn":"","SslMode":"","ServiceAccessRoleArn":"","ExternalTableDefinition":"","DynamoDbSettings":"","S3Settings":"","DmsTransferSettings":"","MongoDbSettings":"","KinesisSettings":"","KafkaSettings":"","ElasticsearchSettings":"","NeptuneSettings":"","RedshiftSettings":{"AcceptAnyDate":"","AfterConnectScript":"","BucketFolder":"","BucketName":"","CaseSensitiveNames":"","CompUpdate":"","ConnectionTimeout":"","DatabaseName":"","DateFormat":"","EmptyAsNull":"","EncryptionMode":"","ExplicitIds":"","FileTransferUploadStreams":"","LoadTimeout":"","MaxFileSize":"","Password":"","Port":"","RemoveQuotes":"","ReplaceInvalidChars":"","ReplaceChars":"","ServerName":"","ServiceAccessRoleArn":"","ServerSideEncryptionKmsKeyId":"","TimeFormat":"","TrimBlanks":"","TruncateColumns":"","Username":"","WriteBufferSize":"","SecretsManagerAccessRoleArn":"","SecretsManagerSecretId":"","MapBooleanAsBoolean":""},"PostgreSQLSettings":"","MySQLSettings":"","OracleSettings":"","SybaseSettings":"","MicrosoftSQLServerSettings":"","IBMDb2Settings":"","ResourceIdentifier":"","DocDbSettings":{"Username":"","Password":"","ServerName":"","Port":"","DatabaseName":"","NestingLevel":"","ExtractDocId":"","DocsToInvestigate":"","KmsKeyId":"","SecretsManagerAccessRoleArn":"","SecretsManagerSecretId":""},"RedisSettings":"","GcpMySQLSettings":""}'
};

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=AmazonDMSv20160101.CreateEndpoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointIdentifier": "",\n  "EndpointType": "",\n  "EngineName": "",\n  "Username": "",\n  "Password": "",\n  "ServerName": "",\n  "Port": "",\n  "DatabaseName": "",\n  "ExtraConnectionAttributes": "",\n  "KmsKeyId": "",\n  "Tags": "",\n  "CertificateArn": "",\n  "SslMode": "",\n  "ServiceAccessRoleArn": "",\n  "ExternalTableDefinition": "",\n  "DynamoDbSettings": "",\n  "S3Settings": "",\n  "DmsTransferSettings": "",\n  "MongoDbSettings": "",\n  "KinesisSettings": "",\n  "KafkaSettings": "",\n  "ElasticsearchSettings": "",\n  "NeptuneSettings": "",\n  "RedshiftSettings": {\n    "AcceptAnyDate": "",\n    "AfterConnectScript": "",\n    "BucketFolder": "",\n    "BucketName": "",\n    "CaseSensitiveNames": "",\n    "CompUpdate": "",\n    "ConnectionTimeout": "",\n    "DatabaseName": "",\n    "DateFormat": "",\n    "EmptyAsNull": "",\n    "EncryptionMode": "",\n    "ExplicitIds": "",\n    "FileTransferUploadStreams": "",\n    "LoadTimeout": "",\n    "MaxFileSize": "",\n    "Password": "",\n    "Port": "",\n    "RemoveQuotes": "",\n    "ReplaceInvalidChars": "",\n    "ReplaceChars": "",\n    "ServerName": "",\n    "ServiceAccessRoleArn": "",\n    "ServerSideEncryptionKmsKeyId": "",\n    "TimeFormat": "",\n    "TrimBlanks": "",\n    "TruncateColumns": "",\n    "Username": "",\n    "WriteBufferSize": "",\n    "SecretsManagerAccessRoleArn": "",\n    "SecretsManagerSecretId": "",\n    "MapBooleanAsBoolean": ""\n  },\n  "PostgreSQLSettings": "",\n  "MySQLSettings": "",\n  "OracleSettings": "",\n  "SybaseSettings": "",\n  "MicrosoftSQLServerSettings": "",\n  "IBMDb2Settings": "",\n  "ResourceIdentifier": "",\n  "DocDbSettings": {\n    "Username": "",\n    "Password": "",\n    "ServerName": "",\n    "Port": "",\n    "DatabaseName": "",\n    "NestingLevel": "",\n    "ExtractDocId": "",\n    "DocsToInvestigate": "",\n    "KmsKeyId": "",\n    "SecretsManagerAccessRoleArn": "",\n    "SecretsManagerSecretId": ""\n  },\n  "RedisSettings": "",\n  "GcpMySQLSettings": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint")
  .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({
  EndpointIdentifier: '',
  EndpointType: '',
  EngineName: '',
  Username: '',
  Password: '',
  ServerName: '',
  Port: '',
  DatabaseName: '',
  ExtraConnectionAttributes: '',
  KmsKeyId: '',
  Tags: '',
  CertificateArn: '',
  SslMode: '',
  ServiceAccessRoleArn: '',
  ExternalTableDefinition: '',
  DynamoDbSettings: '',
  S3Settings: '',
  DmsTransferSettings: '',
  MongoDbSettings: '',
  KinesisSettings: '',
  KafkaSettings: '',
  ElasticsearchSettings: '',
  NeptuneSettings: '',
  RedshiftSettings: {
    AcceptAnyDate: '',
    AfterConnectScript: '',
    BucketFolder: '',
    BucketName: '',
    CaseSensitiveNames: '',
    CompUpdate: '',
    ConnectionTimeout: '',
    DatabaseName: '',
    DateFormat: '',
    EmptyAsNull: '',
    EncryptionMode: '',
    ExplicitIds: '',
    FileTransferUploadStreams: '',
    LoadTimeout: '',
    MaxFileSize: '',
    Password: '',
    Port: '',
    RemoveQuotes: '',
    ReplaceInvalidChars: '',
    ReplaceChars: '',
    ServerName: '',
    ServiceAccessRoleArn: '',
    ServerSideEncryptionKmsKeyId: '',
    TimeFormat: '',
    TrimBlanks: '',
    TruncateColumns: '',
    Username: '',
    WriteBufferSize: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: '',
    MapBooleanAsBoolean: ''
  },
  PostgreSQLSettings: '',
  MySQLSettings: '',
  OracleSettings: '',
  SybaseSettings: '',
  MicrosoftSQLServerSettings: '',
  IBMDb2Settings: '',
  ResourceIdentifier: '',
  DocDbSettings: {
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    NestingLevel: '',
    ExtractDocId: '',
    DocsToInvestigate: '',
    KmsKeyId: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: ''
  },
  RedisSettings: '',
  GcpMySQLSettings: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EndpointIdentifier: '',
    EndpointType: '',
    EngineName: '',
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    ExtraConnectionAttributes: '',
    KmsKeyId: '',
    Tags: '',
    CertificateArn: '',
    SslMode: '',
    ServiceAccessRoleArn: '',
    ExternalTableDefinition: '',
    DynamoDbSettings: '',
    S3Settings: '',
    DmsTransferSettings: '',
    MongoDbSettings: '',
    KinesisSettings: '',
    KafkaSettings: '',
    ElasticsearchSettings: '',
    NeptuneSettings: '',
    RedshiftSettings: {
      AcceptAnyDate: '',
      AfterConnectScript: '',
      BucketFolder: '',
      BucketName: '',
      CaseSensitiveNames: '',
      CompUpdate: '',
      ConnectionTimeout: '',
      DatabaseName: '',
      DateFormat: '',
      EmptyAsNull: '',
      EncryptionMode: '',
      ExplicitIds: '',
      FileTransferUploadStreams: '',
      LoadTimeout: '',
      MaxFileSize: '',
      Password: '',
      Port: '',
      RemoveQuotes: '',
      ReplaceInvalidChars: '',
      ReplaceChars: '',
      ServerName: '',
      ServiceAccessRoleArn: '',
      ServerSideEncryptionKmsKeyId: '',
      TimeFormat: '',
      TrimBlanks: '',
      TruncateColumns: '',
      Username: '',
      WriteBufferSize: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: '',
      MapBooleanAsBoolean: ''
    },
    PostgreSQLSettings: '',
    MySQLSettings: '',
    OracleSettings: '',
    SybaseSettings: '',
    MicrosoftSQLServerSettings: '',
    IBMDb2Settings: '',
    ResourceIdentifier: '',
    DocDbSettings: {
      Username: '',
      Password: '',
      ServerName: '',
      Port: '',
      DatabaseName: '',
      NestingLevel: '',
      ExtractDocId: '',
      DocsToInvestigate: '',
      KmsKeyId: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: ''
    },
    RedisSettings: '',
    GcpMySQLSettings: ''
  },
  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=AmazonDMSv20160101.CreateEndpoint');

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

req.type('json');
req.send({
  EndpointIdentifier: '',
  EndpointType: '',
  EngineName: '',
  Username: '',
  Password: '',
  ServerName: '',
  Port: '',
  DatabaseName: '',
  ExtraConnectionAttributes: '',
  KmsKeyId: '',
  Tags: '',
  CertificateArn: '',
  SslMode: '',
  ServiceAccessRoleArn: '',
  ExternalTableDefinition: '',
  DynamoDbSettings: '',
  S3Settings: '',
  DmsTransferSettings: '',
  MongoDbSettings: '',
  KinesisSettings: '',
  KafkaSettings: '',
  ElasticsearchSettings: '',
  NeptuneSettings: '',
  RedshiftSettings: {
    AcceptAnyDate: '',
    AfterConnectScript: '',
    BucketFolder: '',
    BucketName: '',
    CaseSensitiveNames: '',
    CompUpdate: '',
    ConnectionTimeout: '',
    DatabaseName: '',
    DateFormat: '',
    EmptyAsNull: '',
    EncryptionMode: '',
    ExplicitIds: '',
    FileTransferUploadStreams: '',
    LoadTimeout: '',
    MaxFileSize: '',
    Password: '',
    Port: '',
    RemoveQuotes: '',
    ReplaceInvalidChars: '',
    ReplaceChars: '',
    ServerName: '',
    ServiceAccessRoleArn: '',
    ServerSideEncryptionKmsKeyId: '',
    TimeFormat: '',
    TrimBlanks: '',
    TruncateColumns: '',
    Username: '',
    WriteBufferSize: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: '',
    MapBooleanAsBoolean: ''
  },
  PostgreSQLSettings: '',
  MySQLSettings: '',
  OracleSettings: '',
  SybaseSettings: '',
  MicrosoftSQLServerSettings: '',
  IBMDb2Settings: '',
  ResourceIdentifier: '',
  DocDbSettings: {
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    NestingLevel: '',
    ExtractDocId: '',
    DocsToInvestigate: '',
    KmsKeyId: '',
    SecretsManagerAccessRoleArn: '',
    SecretsManagerSecretId: ''
  },
  RedisSettings: '',
  GcpMySQLSettings: ''
});

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=AmazonDMSv20160101.CreateEndpoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EndpointIdentifier: '',
    EndpointType: '',
    EngineName: '',
    Username: '',
    Password: '',
    ServerName: '',
    Port: '',
    DatabaseName: '',
    ExtraConnectionAttributes: '',
    KmsKeyId: '',
    Tags: '',
    CertificateArn: '',
    SslMode: '',
    ServiceAccessRoleArn: '',
    ExternalTableDefinition: '',
    DynamoDbSettings: '',
    S3Settings: '',
    DmsTransferSettings: '',
    MongoDbSettings: '',
    KinesisSettings: '',
    KafkaSettings: '',
    ElasticsearchSettings: '',
    NeptuneSettings: '',
    RedshiftSettings: {
      AcceptAnyDate: '',
      AfterConnectScript: '',
      BucketFolder: '',
      BucketName: '',
      CaseSensitiveNames: '',
      CompUpdate: '',
      ConnectionTimeout: '',
      DatabaseName: '',
      DateFormat: '',
      EmptyAsNull: '',
      EncryptionMode: '',
      ExplicitIds: '',
      FileTransferUploadStreams: '',
      LoadTimeout: '',
      MaxFileSize: '',
      Password: '',
      Port: '',
      RemoveQuotes: '',
      ReplaceInvalidChars: '',
      ReplaceChars: '',
      ServerName: '',
      ServiceAccessRoleArn: '',
      ServerSideEncryptionKmsKeyId: '',
      TimeFormat: '',
      TrimBlanks: '',
      TruncateColumns: '',
      Username: '',
      WriteBufferSize: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: '',
      MapBooleanAsBoolean: ''
    },
    PostgreSQLSettings: '',
    MySQLSettings: '',
    OracleSettings: '',
    SybaseSettings: '',
    MicrosoftSQLServerSettings: '',
    IBMDb2Settings: '',
    ResourceIdentifier: '',
    DocDbSettings: {
      Username: '',
      Password: '',
      ServerName: '',
      Port: '',
      DatabaseName: '',
      NestingLevel: '',
      ExtractDocId: '',
      DocsToInvestigate: '',
      KmsKeyId: '',
      SecretsManagerAccessRoleArn: '',
      SecretsManagerSecretId: ''
    },
    RedisSettings: '',
    GcpMySQLSettings: ''
  }
};

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=AmazonDMSv20160101.CreateEndpoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointIdentifier":"","EndpointType":"","EngineName":"","Username":"","Password":"","ServerName":"","Port":"","DatabaseName":"","ExtraConnectionAttributes":"","KmsKeyId":"","Tags":"","CertificateArn":"","SslMode":"","ServiceAccessRoleArn":"","ExternalTableDefinition":"","DynamoDbSettings":"","S3Settings":"","DmsTransferSettings":"","MongoDbSettings":"","KinesisSettings":"","KafkaSettings":"","ElasticsearchSettings":"","NeptuneSettings":"","RedshiftSettings":{"AcceptAnyDate":"","AfterConnectScript":"","BucketFolder":"","BucketName":"","CaseSensitiveNames":"","CompUpdate":"","ConnectionTimeout":"","DatabaseName":"","DateFormat":"","EmptyAsNull":"","EncryptionMode":"","ExplicitIds":"","FileTransferUploadStreams":"","LoadTimeout":"","MaxFileSize":"","Password":"","Port":"","RemoveQuotes":"","ReplaceInvalidChars":"","ReplaceChars":"","ServerName":"","ServiceAccessRoleArn":"","ServerSideEncryptionKmsKeyId":"","TimeFormat":"","TrimBlanks":"","TruncateColumns":"","Username":"","WriteBufferSize":"","SecretsManagerAccessRoleArn":"","SecretsManagerSecretId":"","MapBooleanAsBoolean":""},"PostgreSQLSettings":"","MySQLSettings":"","OracleSettings":"","SybaseSettings":"","MicrosoftSQLServerSettings":"","IBMDb2Settings":"","ResourceIdentifier":"","DocDbSettings":{"Username":"","Password":"","ServerName":"","Port":"","DatabaseName":"","NestingLevel":"","ExtractDocId":"","DocsToInvestigate":"","KmsKeyId":"","SecretsManagerAccessRoleArn":"","SecretsManagerSecretId":""},"RedisSettings":"","GcpMySQLSettings":""}'
};

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 = @{ @"EndpointIdentifier": @"",
                              @"EndpointType": @"",
                              @"EngineName": @"",
                              @"Username": @"",
                              @"Password": @"",
                              @"ServerName": @"",
                              @"Port": @"",
                              @"DatabaseName": @"",
                              @"ExtraConnectionAttributes": @"",
                              @"KmsKeyId": @"",
                              @"Tags": @"",
                              @"CertificateArn": @"",
                              @"SslMode": @"",
                              @"ServiceAccessRoleArn": @"",
                              @"ExternalTableDefinition": @"",
                              @"DynamoDbSettings": @"",
                              @"S3Settings": @"",
                              @"DmsTransferSettings": @"",
                              @"MongoDbSettings": @"",
                              @"KinesisSettings": @"",
                              @"KafkaSettings": @"",
                              @"ElasticsearchSettings": @"",
                              @"NeptuneSettings": @"",
                              @"RedshiftSettings": @{ @"AcceptAnyDate": @"", @"AfterConnectScript": @"", @"BucketFolder": @"", @"BucketName": @"", @"CaseSensitiveNames": @"", @"CompUpdate": @"", @"ConnectionTimeout": @"", @"DatabaseName": @"", @"DateFormat": @"", @"EmptyAsNull": @"", @"EncryptionMode": @"", @"ExplicitIds": @"", @"FileTransferUploadStreams": @"", @"LoadTimeout": @"", @"MaxFileSize": @"", @"Password": @"", @"Port": @"", @"RemoveQuotes": @"", @"ReplaceInvalidChars": @"", @"ReplaceChars": @"", @"ServerName": @"", @"ServiceAccessRoleArn": @"", @"ServerSideEncryptionKmsKeyId": @"", @"TimeFormat": @"", @"TrimBlanks": @"", @"TruncateColumns": @"", @"Username": @"", @"WriteBufferSize": @"", @"SecretsManagerAccessRoleArn": @"", @"SecretsManagerSecretId": @"", @"MapBooleanAsBoolean": @"" },
                              @"PostgreSQLSettings": @"",
                              @"MySQLSettings": @"",
                              @"OracleSettings": @"",
                              @"SybaseSettings": @"",
                              @"MicrosoftSQLServerSettings": @"",
                              @"IBMDb2Settings": @"",
                              @"ResourceIdentifier": @"",
                              @"DocDbSettings": @{ @"Username": @"", @"Password": @"", @"ServerName": @"", @"Port": @"", @"DatabaseName": @"", @"NestingLevel": @"", @"ExtractDocId": @"", @"DocsToInvestigate": @"", @"KmsKeyId": @"", @"SecretsManagerAccessRoleArn": @"", @"SecretsManagerSecretId": @"" },
                              @"RedisSettings": @"",
                              @"GcpMySQLSettings": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint"]
                                                       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=AmazonDMSv20160101.CreateEndpoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint",
  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([
    'EndpointIdentifier' => '',
    'EndpointType' => '',
    'EngineName' => '',
    'Username' => '',
    'Password' => '',
    'ServerName' => '',
    'Port' => '',
    'DatabaseName' => '',
    'ExtraConnectionAttributes' => '',
    'KmsKeyId' => '',
    'Tags' => '',
    'CertificateArn' => '',
    'SslMode' => '',
    'ServiceAccessRoleArn' => '',
    'ExternalTableDefinition' => '',
    'DynamoDbSettings' => '',
    'S3Settings' => '',
    'DmsTransferSettings' => '',
    'MongoDbSettings' => '',
    'KinesisSettings' => '',
    'KafkaSettings' => '',
    'ElasticsearchSettings' => '',
    'NeptuneSettings' => '',
    'RedshiftSettings' => [
        'AcceptAnyDate' => '',
        'AfterConnectScript' => '',
        'BucketFolder' => '',
        'BucketName' => '',
        'CaseSensitiveNames' => '',
        'CompUpdate' => '',
        'ConnectionTimeout' => '',
        'DatabaseName' => '',
        'DateFormat' => '',
        'EmptyAsNull' => '',
        'EncryptionMode' => '',
        'ExplicitIds' => '',
        'FileTransferUploadStreams' => '',
        'LoadTimeout' => '',
        'MaxFileSize' => '',
        'Password' => '',
        'Port' => '',
        'RemoveQuotes' => '',
        'ReplaceInvalidChars' => '',
        'ReplaceChars' => '',
        'ServerName' => '',
        'ServiceAccessRoleArn' => '',
        'ServerSideEncryptionKmsKeyId' => '',
        'TimeFormat' => '',
        'TrimBlanks' => '',
        'TruncateColumns' => '',
        'Username' => '',
        'WriteBufferSize' => '',
        'SecretsManagerAccessRoleArn' => '',
        'SecretsManagerSecretId' => '',
        'MapBooleanAsBoolean' => ''
    ],
    'PostgreSQLSettings' => '',
    'MySQLSettings' => '',
    'OracleSettings' => '',
    'SybaseSettings' => '',
    'MicrosoftSQLServerSettings' => '',
    'IBMDb2Settings' => '',
    'ResourceIdentifier' => '',
    'DocDbSettings' => [
        'Username' => '',
        'Password' => '',
        'ServerName' => '',
        'Port' => '',
        'DatabaseName' => '',
        'NestingLevel' => '',
        'ExtractDocId' => '',
        'DocsToInvestigate' => '',
        'KmsKeyId' => '',
        'SecretsManagerAccessRoleArn' => '',
        'SecretsManagerSecretId' => ''
    ],
    'RedisSettings' => '',
    'GcpMySQLSettings' => ''
  ]),
  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=AmazonDMSv20160101.CreateEndpoint', [
  'body' => '{
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": {
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  },
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": {
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  },
  "RedisSettings": "",
  "GcpMySQLSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointIdentifier' => '',
  'EndpointType' => '',
  'EngineName' => '',
  'Username' => '',
  'Password' => '',
  'ServerName' => '',
  'Port' => '',
  'DatabaseName' => '',
  'ExtraConnectionAttributes' => '',
  'KmsKeyId' => '',
  'Tags' => '',
  'CertificateArn' => '',
  'SslMode' => '',
  'ServiceAccessRoleArn' => '',
  'ExternalTableDefinition' => '',
  'DynamoDbSettings' => '',
  'S3Settings' => '',
  'DmsTransferSettings' => '',
  'MongoDbSettings' => '',
  'KinesisSettings' => '',
  'KafkaSettings' => '',
  'ElasticsearchSettings' => '',
  'NeptuneSettings' => '',
  'RedshiftSettings' => [
    'AcceptAnyDate' => '',
    'AfterConnectScript' => '',
    'BucketFolder' => '',
    'BucketName' => '',
    'CaseSensitiveNames' => '',
    'CompUpdate' => '',
    'ConnectionTimeout' => '',
    'DatabaseName' => '',
    'DateFormat' => '',
    'EmptyAsNull' => '',
    'EncryptionMode' => '',
    'ExplicitIds' => '',
    'FileTransferUploadStreams' => '',
    'LoadTimeout' => '',
    'MaxFileSize' => '',
    'Password' => '',
    'Port' => '',
    'RemoveQuotes' => '',
    'ReplaceInvalidChars' => '',
    'ReplaceChars' => '',
    'ServerName' => '',
    'ServiceAccessRoleArn' => '',
    'ServerSideEncryptionKmsKeyId' => '',
    'TimeFormat' => '',
    'TrimBlanks' => '',
    'TruncateColumns' => '',
    'Username' => '',
    'WriteBufferSize' => '',
    'SecretsManagerAccessRoleArn' => '',
    'SecretsManagerSecretId' => '',
    'MapBooleanAsBoolean' => ''
  ],
  'PostgreSQLSettings' => '',
  'MySQLSettings' => '',
  'OracleSettings' => '',
  'SybaseSettings' => '',
  'MicrosoftSQLServerSettings' => '',
  'IBMDb2Settings' => '',
  'ResourceIdentifier' => '',
  'DocDbSettings' => [
    'Username' => '',
    'Password' => '',
    'ServerName' => '',
    'Port' => '',
    'DatabaseName' => '',
    'NestingLevel' => '',
    'ExtractDocId' => '',
    'DocsToInvestigate' => '',
    'KmsKeyId' => '',
    'SecretsManagerAccessRoleArn' => '',
    'SecretsManagerSecretId' => ''
  ],
  'RedisSettings' => '',
  'GcpMySQLSettings' => ''
]));

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

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

append(json_encode([
  'EndpointIdentifier' => '',
  'EndpointType' => '',
  'EngineName' => '',
  'Username' => '',
  'Password' => '',
  'ServerName' => '',
  'Port' => '',
  'DatabaseName' => '',
  'ExtraConnectionAttributes' => '',
  'KmsKeyId' => '',
  'Tags' => '',
  'CertificateArn' => '',
  'SslMode' => '',
  'ServiceAccessRoleArn' => '',
  'ExternalTableDefinition' => '',
  'DynamoDbSettings' => '',
  'S3Settings' => '',
  'DmsTransferSettings' => '',
  'MongoDbSettings' => '',
  'KinesisSettings' => '',
  'KafkaSettings' => '',
  'ElasticsearchSettings' => '',
  'NeptuneSettings' => '',
  'RedshiftSettings' => [
    'AcceptAnyDate' => '',
    'AfterConnectScript' => '',
    'BucketFolder' => '',
    'BucketName' => '',
    'CaseSensitiveNames' => '',
    'CompUpdate' => '',
    'ConnectionTimeout' => '',
    'DatabaseName' => '',
    'DateFormat' => '',
    'EmptyAsNull' => '',
    'EncryptionMode' => '',
    'ExplicitIds' => '',
    'FileTransferUploadStreams' => '',
    'LoadTimeout' => '',
    'MaxFileSize' => '',
    'Password' => '',
    'Port' => '',
    'RemoveQuotes' => '',
    'ReplaceInvalidChars' => '',
    'ReplaceChars' => '',
    'ServerName' => '',
    'ServiceAccessRoleArn' => '',
    'ServerSideEncryptionKmsKeyId' => '',
    'TimeFormat' => '',
    'TrimBlanks' => '',
    'TruncateColumns' => '',
    'Username' => '',
    'WriteBufferSize' => '',
    'SecretsManagerAccessRoleArn' => '',
    'SecretsManagerSecretId' => '',
    'MapBooleanAsBoolean' => ''
  ],
  'PostgreSQLSettings' => '',
  'MySQLSettings' => '',
  'OracleSettings' => '',
  'SybaseSettings' => '',
  'MicrosoftSQLServerSettings' => '',
  'IBMDb2Settings' => '',
  'ResourceIdentifier' => '',
  'DocDbSettings' => [
    'Username' => '',
    'Password' => '',
    'ServerName' => '',
    'Port' => '',
    'DatabaseName' => '',
    'NestingLevel' => '',
    'ExtractDocId' => '',
    'DocsToInvestigate' => '',
    'KmsKeyId' => '',
    'SecretsManagerAccessRoleArn' => '',
    'SecretsManagerSecretId' => ''
  ],
  'RedisSettings' => '',
  'GcpMySQLSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint');
$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=AmazonDMSv20160101.CreateEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": {
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  },
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": {
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  },
  "RedisSettings": "",
  "GcpMySQLSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": {
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  },
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": {
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  },
  "RedisSettings": "",
  "GcpMySQLSettings": ""
}'

import http.client

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

payload = "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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=AmazonDMSv20160101.CreateEndpoint"

payload = {
    "EndpointIdentifier": "",
    "EndpointType": "",
    "EngineName": "",
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "ExtraConnectionAttributes": "",
    "KmsKeyId": "",
    "Tags": "",
    "CertificateArn": "",
    "SslMode": "",
    "ServiceAccessRoleArn": "",
    "ExternalTableDefinition": "",
    "DynamoDbSettings": "",
    "S3Settings": "",
    "DmsTransferSettings": "",
    "MongoDbSettings": "",
    "KinesisSettings": "",
    "KafkaSettings": "",
    "ElasticsearchSettings": "",
    "NeptuneSettings": "",
    "RedshiftSettings": {
        "AcceptAnyDate": "",
        "AfterConnectScript": "",
        "BucketFolder": "",
        "BucketName": "",
        "CaseSensitiveNames": "",
        "CompUpdate": "",
        "ConnectionTimeout": "",
        "DatabaseName": "",
        "DateFormat": "",
        "EmptyAsNull": "",
        "EncryptionMode": "",
        "ExplicitIds": "",
        "FileTransferUploadStreams": "",
        "LoadTimeout": "",
        "MaxFileSize": "",
        "Password": "",
        "Port": "",
        "RemoveQuotes": "",
        "ReplaceInvalidChars": "",
        "ReplaceChars": "",
        "ServerName": "",
        "ServiceAccessRoleArn": "",
        "ServerSideEncryptionKmsKeyId": "",
        "TimeFormat": "",
        "TrimBlanks": "",
        "TruncateColumns": "",
        "Username": "",
        "WriteBufferSize": "",
        "SecretsManagerAccessRoleArn": "",
        "SecretsManagerSecretId": "",
        "MapBooleanAsBoolean": ""
    },
    "PostgreSQLSettings": "",
    "MySQLSettings": "",
    "OracleSettings": "",
    "SybaseSettings": "",
    "MicrosoftSQLServerSettings": "",
    "IBMDb2Settings": "",
    "ResourceIdentifier": "",
    "DocDbSettings": {
        "Username": "",
        "Password": "",
        "ServerName": "",
        "Port": "",
        "DatabaseName": "",
        "NestingLevel": "",
        "ExtractDocId": "",
        "DocsToInvestigate": "",
        "KmsKeyId": "",
        "SecretsManagerAccessRoleArn": "",
        "SecretsManagerSecretId": ""
    },
    "RedisSettings": "",
    "GcpMySQLSettings": ""
}
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=AmazonDMSv20160101.CreateEndpoint"

payload <- "{\n  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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=AmazonDMSv20160101.CreateEndpoint")

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  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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  \"EndpointIdentifier\": \"\",\n  \"EndpointType\": \"\",\n  \"EngineName\": \"\",\n  \"Username\": \"\",\n  \"Password\": \"\",\n  \"ServerName\": \"\",\n  \"Port\": \"\",\n  \"DatabaseName\": \"\",\n  \"ExtraConnectionAttributes\": \"\",\n  \"KmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"CertificateArn\": \"\",\n  \"SslMode\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"ExternalTableDefinition\": \"\",\n  \"DynamoDbSettings\": \"\",\n  \"S3Settings\": \"\",\n  \"DmsTransferSettings\": \"\",\n  \"MongoDbSettings\": \"\",\n  \"KinesisSettings\": \"\",\n  \"KafkaSettings\": \"\",\n  \"ElasticsearchSettings\": \"\",\n  \"NeptuneSettings\": \"\",\n  \"RedshiftSettings\": {\n    \"AcceptAnyDate\": \"\",\n    \"AfterConnectScript\": \"\",\n    \"BucketFolder\": \"\",\n    \"BucketName\": \"\",\n    \"CaseSensitiveNames\": \"\",\n    \"CompUpdate\": \"\",\n    \"ConnectionTimeout\": \"\",\n    \"DatabaseName\": \"\",\n    \"DateFormat\": \"\",\n    \"EmptyAsNull\": \"\",\n    \"EncryptionMode\": \"\",\n    \"ExplicitIds\": \"\",\n    \"FileTransferUploadStreams\": \"\",\n    \"LoadTimeout\": \"\",\n    \"MaxFileSize\": \"\",\n    \"Password\": \"\",\n    \"Port\": \"\",\n    \"RemoveQuotes\": \"\",\n    \"ReplaceInvalidChars\": \"\",\n    \"ReplaceChars\": \"\",\n    \"ServerName\": \"\",\n    \"ServiceAccessRoleArn\": \"\",\n    \"ServerSideEncryptionKmsKeyId\": \"\",\n    \"TimeFormat\": \"\",\n    \"TrimBlanks\": \"\",\n    \"TruncateColumns\": \"\",\n    \"Username\": \"\",\n    \"WriteBufferSize\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\",\n    \"MapBooleanAsBoolean\": \"\"\n  },\n  \"PostgreSQLSettings\": \"\",\n  \"MySQLSettings\": \"\",\n  \"OracleSettings\": \"\",\n  \"SybaseSettings\": \"\",\n  \"MicrosoftSQLServerSettings\": \"\",\n  \"IBMDb2Settings\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"DocDbSettings\": {\n    \"Username\": \"\",\n    \"Password\": \"\",\n    \"ServerName\": \"\",\n    \"Port\": \"\",\n    \"DatabaseName\": \"\",\n    \"NestingLevel\": \"\",\n    \"ExtractDocId\": \"\",\n    \"DocsToInvestigate\": \"\",\n    \"KmsKeyId\": \"\",\n    \"SecretsManagerAccessRoleArn\": \"\",\n    \"SecretsManagerSecretId\": \"\"\n  },\n  \"RedisSettings\": \"\",\n  \"GcpMySQLSettings\": \"\"\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=AmazonDMSv20160101.CreateEndpoint";

    let payload = json!({
        "EndpointIdentifier": "",
        "EndpointType": "",
        "EngineName": "",
        "Username": "",
        "Password": "",
        "ServerName": "",
        "Port": "",
        "DatabaseName": "",
        "ExtraConnectionAttributes": "",
        "KmsKeyId": "",
        "Tags": "",
        "CertificateArn": "",
        "SslMode": "",
        "ServiceAccessRoleArn": "",
        "ExternalTableDefinition": "",
        "DynamoDbSettings": "",
        "S3Settings": "",
        "DmsTransferSettings": "",
        "MongoDbSettings": "",
        "KinesisSettings": "",
        "KafkaSettings": "",
        "ElasticsearchSettings": "",
        "NeptuneSettings": "",
        "RedshiftSettings": json!({
            "AcceptAnyDate": "",
            "AfterConnectScript": "",
            "BucketFolder": "",
            "BucketName": "",
            "CaseSensitiveNames": "",
            "CompUpdate": "",
            "ConnectionTimeout": "",
            "DatabaseName": "",
            "DateFormat": "",
            "EmptyAsNull": "",
            "EncryptionMode": "",
            "ExplicitIds": "",
            "FileTransferUploadStreams": "",
            "LoadTimeout": "",
            "MaxFileSize": "",
            "Password": "",
            "Port": "",
            "RemoveQuotes": "",
            "ReplaceInvalidChars": "",
            "ReplaceChars": "",
            "ServerName": "",
            "ServiceAccessRoleArn": "",
            "ServerSideEncryptionKmsKeyId": "",
            "TimeFormat": "",
            "TrimBlanks": "",
            "TruncateColumns": "",
            "Username": "",
            "WriteBufferSize": "",
            "SecretsManagerAccessRoleArn": "",
            "SecretsManagerSecretId": "",
            "MapBooleanAsBoolean": ""
        }),
        "PostgreSQLSettings": "",
        "MySQLSettings": "",
        "OracleSettings": "",
        "SybaseSettings": "",
        "MicrosoftSQLServerSettings": "",
        "IBMDb2Settings": "",
        "ResourceIdentifier": "",
        "DocDbSettings": json!({
            "Username": "",
            "Password": "",
            "ServerName": "",
            "Port": "",
            "DatabaseName": "",
            "NestingLevel": "",
            "ExtractDocId": "",
            "DocsToInvestigate": "",
            "KmsKeyId": "",
            "SecretsManagerAccessRoleArn": "",
            "SecretsManagerSecretId": ""
        }),
        "RedisSettings": "",
        "GcpMySQLSettings": ""
    });

    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 '{
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": {
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  },
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": {
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  },
  "RedisSettings": "",
  "GcpMySQLSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointIdentifier": "",\n  "EndpointType": "",\n  "EngineName": "",\n  "Username": "",\n  "Password": "",\n  "ServerName": "",\n  "Port": "",\n  "DatabaseName": "",\n  "ExtraConnectionAttributes": "",\n  "KmsKeyId": "",\n  "Tags": "",\n  "CertificateArn": "",\n  "SslMode": "",\n  "ServiceAccessRoleArn": "",\n  "ExternalTableDefinition": "",\n  "DynamoDbSettings": "",\n  "S3Settings": "",\n  "DmsTransferSettings": "",\n  "MongoDbSettings": "",\n  "KinesisSettings": "",\n  "KafkaSettings": "",\n  "ElasticsearchSettings": "",\n  "NeptuneSettings": "",\n  "RedshiftSettings": {\n    "AcceptAnyDate": "",\n    "AfterConnectScript": "",\n    "BucketFolder": "",\n    "BucketName": "",\n    "CaseSensitiveNames": "",\n    "CompUpdate": "",\n    "ConnectionTimeout": "",\n    "DatabaseName": "",\n    "DateFormat": "",\n    "EmptyAsNull": "",\n    "EncryptionMode": "",\n    "ExplicitIds": "",\n    "FileTransferUploadStreams": "",\n    "LoadTimeout": "",\n    "MaxFileSize": "",\n    "Password": "",\n    "Port": "",\n    "RemoveQuotes": "",\n    "ReplaceInvalidChars": "",\n    "ReplaceChars": "",\n    "ServerName": "",\n    "ServiceAccessRoleArn": "",\n    "ServerSideEncryptionKmsKeyId": "",\n    "TimeFormat": "",\n    "TrimBlanks": "",\n    "TruncateColumns": "",\n    "Username": "",\n    "WriteBufferSize": "",\n    "SecretsManagerAccessRoleArn": "",\n    "SecretsManagerSecretId": "",\n    "MapBooleanAsBoolean": ""\n  },\n  "PostgreSQLSettings": "",\n  "MySQLSettings": "",\n  "OracleSettings": "",\n  "SybaseSettings": "",\n  "MicrosoftSQLServerSettings": "",\n  "IBMDb2Settings": "",\n  "ResourceIdentifier": "",\n  "DocDbSettings": {\n    "Username": "",\n    "Password": "",\n    "ServerName": "",\n    "Port": "",\n    "DatabaseName": "",\n    "NestingLevel": "",\n    "ExtractDocId": "",\n    "DocsToInvestigate": "",\n    "KmsKeyId": "",\n    "SecretsManagerAccessRoleArn": "",\n    "SecretsManagerSecretId": ""\n  },\n  "RedisSettings": "",\n  "GcpMySQLSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEndpoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EndpointIdentifier": "",
  "EndpointType": "",
  "EngineName": "",
  "Username": "",
  "Password": "",
  "ServerName": "",
  "Port": "",
  "DatabaseName": "",
  "ExtraConnectionAttributes": "",
  "KmsKeyId": "",
  "Tags": "",
  "CertificateArn": "",
  "SslMode": "",
  "ServiceAccessRoleArn": "",
  "ExternalTableDefinition": "",
  "DynamoDbSettings": "",
  "S3Settings": "",
  "DmsTransferSettings": "",
  "MongoDbSettings": "",
  "KinesisSettings": "",
  "KafkaSettings": "",
  "ElasticsearchSettings": "",
  "NeptuneSettings": "",
  "RedshiftSettings": [
    "AcceptAnyDate": "",
    "AfterConnectScript": "",
    "BucketFolder": "",
    "BucketName": "",
    "CaseSensitiveNames": "",
    "CompUpdate": "",
    "ConnectionTimeout": "",
    "DatabaseName": "",
    "DateFormat": "",
    "EmptyAsNull": "",
    "EncryptionMode": "",
    "ExplicitIds": "",
    "FileTransferUploadStreams": "",
    "LoadTimeout": "",
    "MaxFileSize": "",
    "Password": "",
    "Port": "",
    "RemoveQuotes": "",
    "ReplaceInvalidChars": "",
    "ReplaceChars": "",
    "ServerName": "",
    "ServiceAccessRoleArn": "",
    "ServerSideEncryptionKmsKeyId": "",
    "TimeFormat": "",
    "TrimBlanks": "",
    "TruncateColumns": "",
    "Username": "",
    "WriteBufferSize": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": "",
    "MapBooleanAsBoolean": ""
  ],
  "PostgreSQLSettings": "",
  "MySQLSettings": "",
  "OracleSettings": "",
  "SybaseSettings": "",
  "MicrosoftSQLServerSettings": "",
  "IBMDb2Settings": "",
  "ResourceIdentifier": "",
  "DocDbSettings": [
    "Username": "",
    "Password": "",
    "ServerName": "",
    "Port": "",
    "DatabaseName": "",
    "NestingLevel": "",
    "ExtractDocId": "",
    "DocsToInvestigate": "",
    "KmsKeyId": "",
    "SecretsManagerAccessRoleArn": "",
    "SecretsManagerSecretId": ""
  ],
  "RedisSettings": "",
  "GcpMySQLSettings": ""
] as [String : Any]

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

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

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  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:SubscriptionName ""
                                                                                                                   :SnsTopicArn ""
                                                                                                                   :SourceType ""
                                                                                                                   :EventCategories ""
                                                                                                                   :SourceIds ""
                                                                                                                   :Enabled ""
                                                                                                                   :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription"

	payload := strings.NewReader("{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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: 144

{
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  SubscriptionName: '',
  SnsTopicArn: '',
  SourceType: '',
  EventCategories: '',
  SourceIds: '',
  Enabled: '',
  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=AmazonDMSv20160101.CreateEventSubscription');
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=AmazonDMSv20160101.CreateEventSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SubscriptionName: '',
    SnsTopicArn: '',
    SourceType: '',
    EventCategories: '',
    SourceIds: '',
    Enabled: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionName":"","SnsTopicArn":"","SourceType":"","EventCategories":"","SourceIds":"","Enabled":"","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=AmazonDMSv20160101.CreateEventSubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SubscriptionName": "",\n  "SnsTopicArn": "",\n  "SourceType": "",\n  "EventCategories": "",\n  "SourceIds": "",\n  "Enabled": "",\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  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription")
  .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({
  SubscriptionName: '',
  SnsTopicArn: '',
  SourceType: '',
  EventCategories: '',
  SourceIds: '',
  Enabled: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SubscriptionName: '',
    SnsTopicArn: '',
    SourceType: '',
    EventCategories: '',
    SourceIds: '',
    Enabled: '',
    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=AmazonDMSv20160101.CreateEventSubscription');

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

req.type('json');
req.send({
  SubscriptionName: '',
  SnsTopicArn: '',
  SourceType: '',
  EventCategories: '',
  SourceIds: '',
  Enabled: '',
  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=AmazonDMSv20160101.CreateEventSubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SubscriptionName: '',
    SnsTopicArn: '',
    SourceType: '',
    EventCategories: '',
    SourceIds: '',
    Enabled: '',
    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=AmazonDMSv20160101.CreateEventSubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionName":"","SnsTopicArn":"","SourceType":"","EventCategories":"","SourceIds":"","Enabled":"","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 = @{ @"SubscriptionName": @"",
                              @"SnsTopicArn": @"",
                              @"SourceType": @"",
                              @"EventCategories": @"",
                              @"SourceIds": @"",
                              @"Enabled": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription",
  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([
    'SubscriptionName' => '',
    'SnsTopicArn' => '',
    'SourceType' => '',
    'EventCategories' => '',
    'SourceIds' => '',
    'Enabled' => '',
    '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=AmazonDMSv20160101.CreateEventSubscription', [
  'body' => '{
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SubscriptionName' => '',
  'SnsTopicArn' => '',
  'SourceType' => '',
  'EventCategories' => '',
  'SourceIds' => '',
  'Enabled' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'SubscriptionName' => '',
  'SnsTopicArn' => '',
  'SourceType' => '',
  'EventCategories' => '',
  'SourceIds' => '',
  'Enabled' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription');
$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=AmazonDMSv20160101.CreateEventSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription"

payload = {
    "SubscriptionName": "",
    "SnsTopicArn": "",
    "SourceType": "",
    "EventCategories": "",
    "SourceIds": "",
    "Enabled": "",
    "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=AmazonDMSv20160101.CreateEventSubscription"

payload <- "{\n  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription")

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  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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  \"SubscriptionName\": \"\",\n  \"SnsTopicArn\": \"\",\n  \"SourceType\": \"\",\n  \"EventCategories\": \"\",\n  \"SourceIds\": \"\",\n  \"Enabled\": \"\",\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=AmazonDMSv20160101.CreateEventSubscription";

    let payload = json!({
        "SubscriptionName": "",
        "SnsTopicArn": "",
        "SourceType": "",
        "EventCategories": "",
        "SourceIds": "",
        "Enabled": "",
        "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 '{
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SubscriptionName": "",\n  "SnsTopicArn": "",\n  "SourceType": "",\n  "EventCategories": "",\n  "SourceIds": "",\n  "Enabled": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateEventSubscription'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SubscriptionName": "",
  "SnsTopicArn": "",
  "SourceType": "",
  "EventCategories": "",
  "SourceIds": "",
  "Enabled": "",
  "Tags": ""
] as [String : Any]

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

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

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  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateFleetAdvisorCollector" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:CollectorName ""
                                                                                                                       :Description ""
                                                                                                                       :ServiceAccessRoleArn ""
                                                                                                                       :S3BucketName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateFleetAdvisorCollector"

	payload := strings.NewReader("{\n  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\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: 98

{
  "CollectorName": "",
  "Description": "",
  "ServiceAccessRoleArn": "",
  "S3BucketName": ""
}

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

client.close();

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

const data = JSON.stringify({
  CollectorName: '',
  Description: '',
  ServiceAccessRoleArn: '',
  S3BucketName: ''
});

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=AmazonDMSv20160101.CreateFleetAdvisorCollector');
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=AmazonDMSv20160101.CreateFleetAdvisorCollector',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CollectorName: '', Description: '', ServiceAccessRoleArn: '', S3BucketName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateFleetAdvisorCollector';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CollectorName":"","Description":"","ServiceAccessRoleArn":"","S3BucketName":""}'
};

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=AmazonDMSv20160101.CreateFleetAdvisorCollector',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CollectorName": "",\n  "Description": "",\n  "ServiceAccessRoleArn": "",\n  "S3BucketName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  CollectorName: '',
  Description: '',
  ServiceAccessRoleArn: '',
  S3BucketName: ''
});

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=AmazonDMSv20160101.CreateFleetAdvisorCollector',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CollectorName: '', Description: '', ServiceAccessRoleArn: '', S3BucketName: ''}
};

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=AmazonDMSv20160101.CreateFleetAdvisorCollector';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CollectorName":"","Description":"","ServiceAccessRoleArn":"","S3BucketName":""}'
};

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 = @{ @"CollectorName": @"",
                              @"Description": @"",
                              @"ServiceAccessRoleArn": @"",
                              @"S3BucketName": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CollectorName' => '',
  'Description' => '',
  'ServiceAccessRoleArn' => '',
  'S3BucketName' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\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=AmazonDMSv20160101.CreateFleetAdvisorCollector"

payload = {
    "CollectorName": "",
    "Description": "",
    "ServiceAccessRoleArn": "",
    "S3BucketName": ""
}
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=AmazonDMSv20160101.CreateFleetAdvisorCollector"

payload <- "{\n  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\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=AmazonDMSv20160101.CreateFleetAdvisorCollector")

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  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\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  \"CollectorName\": \"\",\n  \"Description\": \"\",\n  \"ServiceAccessRoleArn\": \"\",\n  \"S3BucketName\": \"\"\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=AmazonDMSv20160101.CreateFleetAdvisorCollector";

    let payload = json!({
        "CollectorName": "",
        "Description": "",
        "ServiceAccessRoleArn": "",
        "S3BucketName": ""
    });

    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 '{
  "CollectorName": "",
  "Description": "",
  "ServiceAccessRoleArn": "",
  "S3BucketName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateFleetAdvisorCollector' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CollectorName": "",\n  "Description": "",\n  "ServiceAccessRoleArn": "",\n  "S3BucketName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateFleetAdvisorCollector'

import Foundation

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

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

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

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  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:ReplicationInstanceIdentifier ""
                                                                                                                     :AllocatedStorage ""
                                                                                                                     :ReplicationInstanceClass ""
                                                                                                                     :VpcSecurityGroupIds ""
                                                                                                                     :AvailabilityZone ""
                                                                                                                     :ReplicationSubnetGroupIdentifier ""
                                                                                                                     :PreferredMaintenanceWindow ""
                                                                                                                     :MultiAZ ""
                                                                                                                     :EngineVersion ""
                                                                                                                     :AutoMinorVersionUpgrade ""
                                                                                                                     :Tags ""
                                                                                                                     :KmsKeyId ""
                                                                                                                     :PubliclyAccessible ""
                                                                                                                     :DnsNameServers ""
                                                                                                                     :ResourceIdentifier ""
                                                                                                                     :NetworkType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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=AmazonDMSv20160101.CreateReplicationInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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=AmazonDMSv20160101.CreateReplicationInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance"

	payload := strings.NewReader("{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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: 440

{
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance")
  .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=AmazonDMSv20160101.CreateReplicationInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationInstanceIdentifier: '',
  AllocatedStorage: '',
  ReplicationInstanceClass: '',
  VpcSecurityGroupIds: '',
  AvailabilityZone: '',
  ReplicationSubnetGroupIdentifier: '',
  PreferredMaintenanceWindow: '',
  MultiAZ: '',
  EngineVersion: '',
  AutoMinorVersionUpgrade: '',
  Tags: '',
  KmsKeyId: '',
  PubliclyAccessible: '',
  DnsNameServers: '',
  ResourceIdentifier: '',
  NetworkType: ''
});

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=AmazonDMSv20160101.CreateReplicationInstance');
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=AmazonDMSv20160101.CreateReplicationInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationInstanceIdentifier: '',
    AllocatedStorage: '',
    ReplicationInstanceClass: '',
    VpcSecurityGroupIds: '',
    AvailabilityZone: '',
    ReplicationSubnetGroupIdentifier: '',
    PreferredMaintenanceWindow: '',
    MultiAZ: '',
    EngineVersion: '',
    AutoMinorVersionUpgrade: '',
    Tags: '',
    KmsKeyId: '',
    PubliclyAccessible: '',
    DnsNameServers: '',
    ResourceIdentifier: '',
    NetworkType: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceIdentifier":"","AllocatedStorage":"","ReplicationInstanceClass":"","VpcSecurityGroupIds":"","AvailabilityZone":"","ReplicationSubnetGroupIdentifier":"","PreferredMaintenanceWindow":"","MultiAZ":"","EngineVersion":"","AutoMinorVersionUpgrade":"","Tags":"","KmsKeyId":"","PubliclyAccessible":"","DnsNameServers":"","ResourceIdentifier":"","NetworkType":""}'
};

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=AmazonDMSv20160101.CreateReplicationInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationInstanceIdentifier": "",\n  "AllocatedStorage": "",\n  "ReplicationInstanceClass": "",\n  "VpcSecurityGroupIds": "",\n  "AvailabilityZone": "",\n  "ReplicationSubnetGroupIdentifier": "",\n  "PreferredMaintenanceWindow": "",\n  "MultiAZ": "",\n  "EngineVersion": "",\n  "AutoMinorVersionUpgrade": "",\n  "Tags": "",\n  "KmsKeyId": "",\n  "PubliclyAccessible": "",\n  "DnsNameServers": "",\n  "ResourceIdentifier": "",\n  "NetworkType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance")
  .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({
  ReplicationInstanceIdentifier: '',
  AllocatedStorage: '',
  ReplicationInstanceClass: '',
  VpcSecurityGroupIds: '',
  AvailabilityZone: '',
  ReplicationSubnetGroupIdentifier: '',
  PreferredMaintenanceWindow: '',
  MultiAZ: '',
  EngineVersion: '',
  AutoMinorVersionUpgrade: '',
  Tags: '',
  KmsKeyId: '',
  PubliclyAccessible: '',
  DnsNameServers: '',
  ResourceIdentifier: '',
  NetworkType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ReplicationInstanceIdentifier: '',
    AllocatedStorage: '',
    ReplicationInstanceClass: '',
    VpcSecurityGroupIds: '',
    AvailabilityZone: '',
    ReplicationSubnetGroupIdentifier: '',
    PreferredMaintenanceWindow: '',
    MultiAZ: '',
    EngineVersion: '',
    AutoMinorVersionUpgrade: '',
    Tags: '',
    KmsKeyId: '',
    PubliclyAccessible: '',
    DnsNameServers: '',
    ResourceIdentifier: '',
    NetworkType: ''
  },
  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=AmazonDMSv20160101.CreateReplicationInstance');

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

req.type('json');
req.send({
  ReplicationInstanceIdentifier: '',
  AllocatedStorage: '',
  ReplicationInstanceClass: '',
  VpcSecurityGroupIds: '',
  AvailabilityZone: '',
  ReplicationSubnetGroupIdentifier: '',
  PreferredMaintenanceWindow: '',
  MultiAZ: '',
  EngineVersion: '',
  AutoMinorVersionUpgrade: '',
  Tags: '',
  KmsKeyId: '',
  PubliclyAccessible: '',
  DnsNameServers: '',
  ResourceIdentifier: '',
  NetworkType: ''
});

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=AmazonDMSv20160101.CreateReplicationInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationInstanceIdentifier: '',
    AllocatedStorage: '',
    ReplicationInstanceClass: '',
    VpcSecurityGroupIds: '',
    AvailabilityZone: '',
    ReplicationSubnetGroupIdentifier: '',
    PreferredMaintenanceWindow: '',
    MultiAZ: '',
    EngineVersion: '',
    AutoMinorVersionUpgrade: '',
    Tags: '',
    KmsKeyId: '',
    PubliclyAccessible: '',
    DnsNameServers: '',
    ResourceIdentifier: '',
    NetworkType: ''
  }
};

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=AmazonDMSv20160101.CreateReplicationInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceIdentifier":"","AllocatedStorage":"","ReplicationInstanceClass":"","VpcSecurityGroupIds":"","AvailabilityZone":"","ReplicationSubnetGroupIdentifier":"","PreferredMaintenanceWindow":"","MultiAZ":"","EngineVersion":"","AutoMinorVersionUpgrade":"","Tags":"","KmsKeyId":"","PubliclyAccessible":"","DnsNameServers":"","ResourceIdentifier":"","NetworkType":""}'
};

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 = @{ @"ReplicationInstanceIdentifier": @"",
                              @"AllocatedStorage": @"",
                              @"ReplicationInstanceClass": @"",
                              @"VpcSecurityGroupIds": @"",
                              @"AvailabilityZone": @"",
                              @"ReplicationSubnetGroupIdentifier": @"",
                              @"PreferredMaintenanceWindow": @"",
                              @"MultiAZ": @"",
                              @"EngineVersion": @"",
                              @"AutoMinorVersionUpgrade": @"",
                              @"Tags": @"",
                              @"KmsKeyId": @"",
                              @"PubliclyAccessible": @"",
                              @"DnsNameServers": @"",
                              @"ResourceIdentifier": @"",
                              @"NetworkType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance"]
                                                       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=AmazonDMSv20160101.CreateReplicationInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance",
  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([
    'ReplicationInstanceIdentifier' => '',
    'AllocatedStorage' => '',
    'ReplicationInstanceClass' => '',
    'VpcSecurityGroupIds' => '',
    'AvailabilityZone' => '',
    'ReplicationSubnetGroupIdentifier' => '',
    'PreferredMaintenanceWindow' => '',
    'MultiAZ' => '',
    'EngineVersion' => '',
    'AutoMinorVersionUpgrade' => '',
    'Tags' => '',
    'KmsKeyId' => '',
    'PubliclyAccessible' => '',
    'DnsNameServers' => '',
    'ResourceIdentifier' => '',
    'NetworkType' => ''
  ]),
  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=AmazonDMSv20160101.CreateReplicationInstance', [
  'body' => '{
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationInstanceIdentifier' => '',
  'AllocatedStorage' => '',
  'ReplicationInstanceClass' => '',
  'VpcSecurityGroupIds' => '',
  'AvailabilityZone' => '',
  'ReplicationSubnetGroupIdentifier' => '',
  'PreferredMaintenanceWindow' => '',
  'MultiAZ' => '',
  'EngineVersion' => '',
  'AutoMinorVersionUpgrade' => '',
  'Tags' => '',
  'KmsKeyId' => '',
  'PubliclyAccessible' => '',
  'DnsNameServers' => '',
  'ResourceIdentifier' => '',
  'NetworkType' => ''
]));

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

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

append(json_encode([
  'ReplicationInstanceIdentifier' => '',
  'AllocatedStorage' => '',
  'ReplicationInstanceClass' => '',
  'VpcSecurityGroupIds' => '',
  'AvailabilityZone' => '',
  'ReplicationSubnetGroupIdentifier' => '',
  'PreferredMaintenanceWindow' => '',
  'MultiAZ' => '',
  'EngineVersion' => '',
  'AutoMinorVersionUpgrade' => '',
  'Tags' => '',
  'KmsKeyId' => '',
  'PubliclyAccessible' => '',
  'DnsNameServers' => '',
  'ResourceIdentifier' => '',
  'NetworkType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance');
$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=AmazonDMSv20160101.CreateReplicationInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
}'

import http.client

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

payload = "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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=AmazonDMSv20160101.CreateReplicationInstance"

payload = {
    "ReplicationInstanceIdentifier": "",
    "AllocatedStorage": "",
    "ReplicationInstanceClass": "",
    "VpcSecurityGroupIds": "",
    "AvailabilityZone": "",
    "ReplicationSubnetGroupIdentifier": "",
    "PreferredMaintenanceWindow": "",
    "MultiAZ": "",
    "EngineVersion": "",
    "AutoMinorVersionUpgrade": "",
    "Tags": "",
    "KmsKeyId": "",
    "PubliclyAccessible": "",
    "DnsNameServers": "",
    "ResourceIdentifier": "",
    "NetworkType": ""
}
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=AmazonDMSv20160101.CreateReplicationInstance"

payload <- "{\n  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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=AmazonDMSv20160101.CreateReplicationInstance")

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  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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  \"ReplicationInstanceIdentifier\": \"\",\n  \"AllocatedStorage\": \"\",\n  \"ReplicationInstanceClass\": \"\",\n  \"VpcSecurityGroupIds\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"PreferredMaintenanceWindow\": \"\",\n  \"MultiAZ\": \"\",\n  \"EngineVersion\": \"\",\n  \"AutoMinorVersionUpgrade\": \"\",\n  \"Tags\": \"\",\n  \"KmsKeyId\": \"\",\n  \"PubliclyAccessible\": \"\",\n  \"DnsNameServers\": \"\",\n  \"ResourceIdentifier\": \"\",\n  \"NetworkType\": \"\"\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=AmazonDMSv20160101.CreateReplicationInstance";

    let payload = json!({
        "ReplicationInstanceIdentifier": "",
        "AllocatedStorage": "",
        "ReplicationInstanceClass": "",
        "VpcSecurityGroupIds": "",
        "AvailabilityZone": "",
        "ReplicationSubnetGroupIdentifier": "",
        "PreferredMaintenanceWindow": "",
        "MultiAZ": "",
        "EngineVersion": "",
        "AutoMinorVersionUpgrade": "",
        "Tags": "",
        "KmsKeyId": "",
        "PubliclyAccessible": "",
        "DnsNameServers": "",
        "ResourceIdentifier": "",
        "NetworkType": ""
    });

    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 '{
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationInstanceIdentifier": "",\n  "AllocatedStorage": "",\n  "ReplicationInstanceClass": "",\n  "VpcSecurityGroupIds": "",\n  "AvailabilityZone": "",\n  "ReplicationSubnetGroupIdentifier": "",\n  "PreferredMaintenanceWindow": "",\n  "MultiAZ": "",\n  "EngineVersion": "",\n  "AutoMinorVersionUpgrade": "",\n  "Tags": "",\n  "KmsKeyId": "",\n  "PubliclyAccessible": "",\n  "DnsNameServers": "",\n  "ResourceIdentifier": "",\n  "NetworkType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationInstanceIdentifier": "",
  "AllocatedStorage": "",
  "ReplicationInstanceClass": "",
  "VpcSecurityGroupIds": "",
  "AvailabilityZone": "",
  "ReplicationSubnetGroupIdentifier": "",
  "PreferredMaintenanceWindow": "",
  "MultiAZ": "",
  "EngineVersion": "",
  "AutoMinorVersionUpgrade": "",
  "Tags": "",
  "KmsKeyId": "",
  "PubliclyAccessible": "",
  "DnsNameServers": "",
  "ResourceIdentifier": "",
  "NetworkType": ""
] as [String : Any]

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

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

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  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationSubnetGroup" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:ReplicationSubnetGroupIdentifier ""
                                                                                                                        :ReplicationSubnetGroupDescription ""
                                                                                                                        :SubnetIds ""
                                                                                                                        :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationSubnetGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup"

	payload := strings.NewReader("{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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: 120

{
  "ReplicationSubnetGroupIdentifier": "",
  "ReplicationSubnetGroupDescription": "",
  "SubnetIds": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ReplicationSubnetGroupIdentifier: '',
  ReplicationSubnetGroupDescription: '',
  SubnetIds: '',
  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=AmazonDMSv20160101.CreateReplicationSubnetGroup');
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=AmazonDMSv20160101.CreateReplicationSubnetGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationSubnetGroupIdentifier: '',
    ReplicationSubnetGroupDescription: '',
    SubnetIds: '',
    Tags: ''
  }
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  ReplicationSubnetGroupIdentifier: '',
  ReplicationSubnetGroupDescription: '',
  SubnetIds: '',
  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=AmazonDMSv20160101.CreateReplicationSubnetGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationSubnetGroupIdentifier: '',
    ReplicationSubnetGroupDescription: '',
    SubnetIds: '',
    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=AmazonDMSv20160101.CreateReplicationSubnetGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationSubnetGroupIdentifier":"","ReplicationSubnetGroupDescription":"","SubnetIds":"","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 = @{ @"ReplicationSubnetGroupIdentifier": @"",
                              @"ReplicationSubnetGroupDescription": @"",
                              @"SubnetIds": @"",
                              @"Tags": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationSubnetGroupIdentifier' => '',
  'ReplicationSubnetGroupDescription' => '',
  'SubnetIds' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup"

payload = {
    "ReplicationSubnetGroupIdentifier": "",
    "ReplicationSubnetGroupDescription": "",
    "SubnetIds": "",
    "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=AmazonDMSv20160101.CreateReplicationSubnetGroup"

payload <- "{\n  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup")

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  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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  \"ReplicationSubnetGroupIdentifier\": \"\",\n  \"ReplicationSubnetGroupDescription\": \"\",\n  \"SubnetIds\": \"\",\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=AmazonDMSv20160101.CreateReplicationSubnetGroup";

    let payload = json!({
        "ReplicationSubnetGroupIdentifier": "",
        "ReplicationSubnetGroupDescription": "",
        "SubnetIds": "",
        "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 '{
  "ReplicationSubnetGroupIdentifier": "",
  "ReplicationSubnetGroupDescription": "",
  "SubnetIds": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationSubnetGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationSubnetGroupIdentifier": "",\n  "ReplicationSubnetGroupDescription": "",\n  "SubnetIds": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationSubnetGroup'

import Foundation

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

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

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

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  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:ReplicationTaskIdentifier ""
                                                                                                                 :SourceEndpointArn ""
                                                                                                                 :TargetEndpointArn ""
                                                                                                                 :ReplicationInstanceArn ""
                                                                                                                 :MigrationType ""
                                                                                                                 :TableMappings ""
                                                                                                                 :ReplicationTaskSettings ""
                                                                                                                 :CdcStartTime ""
                                                                                                                 :CdcStartPosition ""
                                                                                                                 :CdcStopPosition ""
                                                                                                                 :Tags ""
                                                                                                                 :TaskData ""
                                                                                                                 :ResourceIdentifier ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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=AmazonDMSv20160101.CreateReplicationTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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=AmazonDMSv20160101.CreateReplicationTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask"

	payload := strings.NewReader("{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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: 335

{
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask")
  .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=AmazonDMSv20160101.CreateReplicationTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationTaskIdentifier: '',
  SourceEndpointArn: '',
  TargetEndpointArn: '',
  ReplicationInstanceArn: '',
  MigrationType: '',
  TableMappings: '',
  ReplicationTaskSettings: '',
  CdcStartTime: '',
  CdcStartPosition: '',
  CdcStopPosition: '',
  Tags: '',
  TaskData: '',
  ResourceIdentifier: ''
});

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=AmazonDMSv20160101.CreateReplicationTask');
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=AmazonDMSv20160101.CreateReplicationTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationTaskIdentifier: '',
    SourceEndpointArn: '',
    TargetEndpointArn: '',
    ReplicationInstanceArn: '',
    MigrationType: '',
    TableMappings: '',
    ReplicationTaskSettings: '',
    CdcStartTime: '',
    CdcStartPosition: '',
    CdcStopPosition: '',
    Tags: '',
    TaskData: '',
    ResourceIdentifier: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskIdentifier":"","SourceEndpointArn":"","TargetEndpointArn":"","ReplicationInstanceArn":"","MigrationType":"","TableMappings":"","ReplicationTaskSettings":"","CdcStartTime":"","CdcStartPosition":"","CdcStopPosition":"","Tags":"","TaskData":"","ResourceIdentifier":""}'
};

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=AmazonDMSv20160101.CreateReplicationTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationTaskIdentifier": "",\n  "SourceEndpointArn": "",\n  "TargetEndpointArn": "",\n  "ReplicationInstanceArn": "",\n  "MigrationType": "",\n  "TableMappings": "",\n  "ReplicationTaskSettings": "",\n  "CdcStartTime": "",\n  "CdcStartPosition": "",\n  "CdcStopPosition": "",\n  "Tags": "",\n  "TaskData": "",\n  "ResourceIdentifier": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask")
  .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({
  ReplicationTaskIdentifier: '',
  SourceEndpointArn: '',
  TargetEndpointArn: '',
  ReplicationInstanceArn: '',
  MigrationType: '',
  TableMappings: '',
  ReplicationTaskSettings: '',
  CdcStartTime: '',
  CdcStartPosition: '',
  CdcStopPosition: '',
  Tags: '',
  TaskData: '',
  ResourceIdentifier: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ReplicationTaskIdentifier: '',
    SourceEndpointArn: '',
    TargetEndpointArn: '',
    ReplicationInstanceArn: '',
    MigrationType: '',
    TableMappings: '',
    ReplicationTaskSettings: '',
    CdcStartTime: '',
    CdcStartPosition: '',
    CdcStopPosition: '',
    Tags: '',
    TaskData: '',
    ResourceIdentifier: ''
  },
  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=AmazonDMSv20160101.CreateReplicationTask');

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

req.type('json');
req.send({
  ReplicationTaskIdentifier: '',
  SourceEndpointArn: '',
  TargetEndpointArn: '',
  ReplicationInstanceArn: '',
  MigrationType: '',
  TableMappings: '',
  ReplicationTaskSettings: '',
  CdcStartTime: '',
  CdcStartPosition: '',
  CdcStopPosition: '',
  Tags: '',
  TaskData: '',
  ResourceIdentifier: ''
});

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=AmazonDMSv20160101.CreateReplicationTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationTaskIdentifier: '',
    SourceEndpointArn: '',
    TargetEndpointArn: '',
    ReplicationInstanceArn: '',
    MigrationType: '',
    TableMappings: '',
    ReplicationTaskSettings: '',
    CdcStartTime: '',
    CdcStartPosition: '',
    CdcStopPosition: '',
    Tags: '',
    TaskData: '',
    ResourceIdentifier: ''
  }
};

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=AmazonDMSv20160101.CreateReplicationTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskIdentifier":"","SourceEndpointArn":"","TargetEndpointArn":"","ReplicationInstanceArn":"","MigrationType":"","TableMappings":"","ReplicationTaskSettings":"","CdcStartTime":"","CdcStartPosition":"","CdcStopPosition":"","Tags":"","TaskData":"","ResourceIdentifier":""}'
};

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 = @{ @"ReplicationTaskIdentifier": @"",
                              @"SourceEndpointArn": @"",
                              @"TargetEndpointArn": @"",
                              @"ReplicationInstanceArn": @"",
                              @"MigrationType": @"",
                              @"TableMappings": @"",
                              @"ReplicationTaskSettings": @"",
                              @"CdcStartTime": @"",
                              @"CdcStartPosition": @"",
                              @"CdcStopPosition": @"",
                              @"Tags": @"",
                              @"TaskData": @"",
                              @"ResourceIdentifier": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask"]
                                                       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=AmazonDMSv20160101.CreateReplicationTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask",
  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([
    'ReplicationTaskIdentifier' => '',
    'SourceEndpointArn' => '',
    'TargetEndpointArn' => '',
    'ReplicationInstanceArn' => '',
    'MigrationType' => '',
    'TableMappings' => '',
    'ReplicationTaskSettings' => '',
    'CdcStartTime' => '',
    'CdcStartPosition' => '',
    'CdcStopPosition' => '',
    'Tags' => '',
    'TaskData' => '',
    'ResourceIdentifier' => ''
  ]),
  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=AmazonDMSv20160101.CreateReplicationTask', [
  'body' => '{
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationTaskIdentifier' => '',
  'SourceEndpointArn' => '',
  'TargetEndpointArn' => '',
  'ReplicationInstanceArn' => '',
  'MigrationType' => '',
  'TableMappings' => '',
  'ReplicationTaskSettings' => '',
  'CdcStartTime' => '',
  'CdcStartPosition' => '',
  'CdcStopPosition' => '',
  'Tags' => '',
  'TaskData' => '',
  'ResourceIdentifier' => ''
]));

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

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

append(json_encode([
  'ReplicationTaskIdentifier' => '',
  'SourceEndpointArn' => '',
  'TargetEndpointArn' => '',
  'ReplicationInstanceArn' => '',
  'MigrationType' => '',
  'TableMappings' => '',
  'ReplicationTaskSettings' => '',
  'CdcStartTime' => '',
  'CdcStartPosition' => '',
  'CdcStopPosition' => '',
  'Tags' => '',
  'TaskData' => '',
  'ResourceIdentifier' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask');
$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=AmazonDMSv20160101.CreateReplicationTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
}'

import http.client

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

payload = "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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=AmazonDMSv20160101.CreateReplicationTask"

payload = {
    "ReplicationTaskIdentifier": "",
    "SourceEndpointArn": "",
    "TargetEndpointArn": "",
    "ReplicationInstanceArn": "",
    "MigrationType": "",
    "TableMappings": "",
    "ReplicationTaskSettings": "",
    "CdcStartTime": "",
    "CdcStartPosition": "",
    "CdcStopPosition": "",
    "Tags": "",
    "TaskData": "",
    "ResourceIdentifier": ""
}
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=AmazonDMSv20160101.CreateReplicationTask"

payload <- "{\n  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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=AmazonDMSv20160101.CreateReplicationTask")

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  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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  \"ReplicationTaskIdentifier\": \"\",\n  \"SourceEndpointArn\": \"\",\n  \"TargetEndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"MigrationType\": \"\",\n  \"TableMappings\": \"\",\n  \"ReplicationTaskSettings\": \"\",\n  \"CdcStartTime\": \"\",\n  \"CdcStartPosition\": \"\",\n  \"CdcStopPosition\": \"\",\n  \"Tags\": \"\",\n  \"TaskData\": \"\",\n  \"ResourceIdentifier\": \"\"\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=AmazonDMSv20160101.CreateReplicationTask";

    let payload = json!({
        "ReplicationTaskIdentifier": "",
        "SourceEndpointArn": "",
        "TargetEndpointArn": "",
        "ReplicationInstanceArn": "",
        "MigrationType": "",
        "TableMappings": "",
        "ReplicationTaskSettings": "",
        "CdcStartTime": "",
        "CdcStartPosition": "",
        "CdcStopPosition": "",
        "Tags": "",
        "TaskData": "",
        "ResourceIdentifier": ""
    });

    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 '{
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationTaskIdentifier": "",\n  "SourceEndpointArn": "",\n  "TargetEndpointArn": "",\n  "ReplicationInstanceArn": "",\n  "MigrationType": "",\n  "TableMappings": "",\n  "ReplicationTaskSettings": "",\n  "CdcStartTime": "",\n  "CdcStartPosition": "",\n  "CdcStopPosition": "",\n  "Tags": "",\n  "TaskData": "",\n  "ResourceIdentifier": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.CreateReplicationTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationTaskIdentifier": "",
  "SourceEndpointArn": "",
  "TargetEndpointArn": "",
  "ReplicationInstanceArn": "",
  "MigrationType": "",
  "TableMappings": "",
  "ReplicationTaskSettings": "",
  "CdcStartTime": "",
  "CdcStartPosition": "",
  "CdcStopPosition": "",
  "Tags": "",
  "TaskData": "",
  "ResourceIdentifier": ""
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteCertificate"

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

{
  "CertificateArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"CertificateArn\": \"\"\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=AmazonDMSv20160101.DeleteCertificate"

payload = { "CertificateArn": "" }
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=AmazonDMSv20160101.DeleteCertificate"

payload <- "{\n  \"CertificateArn\": \"\"\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=AmazonDMSv20160101.DeleteCertificate")

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  \"CertificateArn\": \"\"\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  \"CertificateArn\": \"\"\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=AmazonDMSv20160101.DeleteCertificate";

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

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

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

import Foundation

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

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:EndpointArn ""
                                                                                                            :ReplicationInstanceArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection"

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

{
  "EndpointArn": "",
  "ReplicationInstanceArn": ""
}

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

client.close();

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

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

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

const data = JSON.stringify({
  EndpointArn: '',
  ReplicationInstanceArn: ''
});

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=AmazonDMSv20160101.DeleteConnection');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({EndpointArn: '', ReplicationInstanceArn: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  EndpointArn: '',
  ReplicationInstanceArn: ''
});

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=AmazonDMSv20160101.DeleteConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointArn: '', ReplicationInstanceArn: ''}
};

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'EndpointArn' => '',
  'ReplicationInstanceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"EndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteConnection"

payload = {
    "EndpointArn": "",
    "ReplicationInstanceArn": ""
}
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=AmazonDMSv20160101.DeleteConnection"

payload <- "{\n  \"EndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteConnection")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"EndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\"\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  \"EndpointArn\": \"\",\n  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteConnection";

    let payload = json!({
        "EndpointArn": "",
        "ReplicationInstanceArn": ""
    });

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

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteConnection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteEndpoint"

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

{
  "EndpointArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DeleteEndpoint"

payload = { "EndpointArn": "" }
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=AmazonDMSv20160101.DeleteEndpoint"

payload <- "{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DeleteEndpoint")

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  \"EndpointArn\": \"\"\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  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DeleteEndpoint";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteEventSubscription"

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

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

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

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

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

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

}

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

{
  "SubscriptionName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"SubscriptionName\": \"\"\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=AmazonDMSv20160101.DeleteEventSubscription"

payload = { "SubscriptionName": "" }
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=AmazonDMSv20160101.DeleteEventSubscription"

payload <- "{\n  \"SubscriptionName\": \"\"\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=AmazonDMSv20160101.DeleteEventSubscription")

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  \"SubscriptionName\": \"\"\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  \"SubscriptionName\": \"\"\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=AmazonDMSv20160101.DeleteEventSubscription";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteFleetAdvisorCollector"

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

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

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

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

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

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

}

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

{
  "CollectorReferencedId": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"CollectorReferencedId\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorCollector"

payload = { "CollectorReferencedId": "" }
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=AmazonDMSv20160101.DeleteFleetAdvisorCollector"

payload <- "{\n  \"CollectorReferencedId\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorCollector")

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  \"CollectorReferencedId\": \"\"\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  \"CollectorReferencedId\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorCollector";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteFleetAdvisorDatabases"

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

{
  "DatabaseIds": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"DatabaseIds\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorDatabases"

payload = { "DatabaseIds": "" }
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=AmazonDMSv20160101.DeleteFleetAdvisorDatabases"

payload <- "{\n  \"DatabaseIds\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorDatabases")

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  \"DatabaseIds\": \"\"\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  \"DatabaseIds\": \"\"\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=AmazonDMSv20160101.DeleteFleetAdvisorDatabases";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteReplicationInstance"

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

{
  "ReplicationInstanceArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationInstance"

payload = { "ReplicationInstanceArn": "" }
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=AmazonDMSv20160101.DeleteReplicationInstance"

payload <- "{\n  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationInstance")

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  \"ReplicationInstanceArn\": \"\"\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  \"ReplicationInstanceArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationInstance";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteReplicationSubnetGroup"

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

{
  "ReplicationSubnetGroupIdentifier": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationSubnetGroupIdentifier\": \"\"\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=AmazonDMSv20160101.DeleteReplicationSubnetGroup"

payload = { "ReplicationSubnetGroupIdentifier": "" }
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=AmazonDMSv20160101.DeleteReplicationSubnetGroup"

payload <- "{\n  \"ReplicationSubnetGroupIdentifier\": \"\"\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=AmazonDMSv20160101.DeleteReplicationSubnetGroup")

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  \"ReplicationSubnetGroupIdentifier\": \"\"\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  \"ReplicationSubnetGroupIdentifier\": \"\"\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=AmazonDMSv20160101.DeleteReplicationSubnetGroup";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteReplicationTask"

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

{
  "ReplicationTaskArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationTaskArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTask"

payload = { "ReplicationTaskArn": "" }
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=AmazonDMSv20160101.DeleteReplicationTask"

payload <- "{\n  \"ReplicationTaskArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTask")

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  \"ReplicationTaskArn\": \"\"\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  \"ReplicationTaskArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTask";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun"

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

{
  "ReplicationTaskAssessmentRunArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun"

payload = { "ReplicationTaskAssessmentRunArn": "" }
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=AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun"

payload <- "{\n  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun")

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  \"ReplicationTaskAssessmentRunArn\": \"\"\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  \"ReplicationTaskAssessmentRunArn\": \"\"\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=AmazonDMSv20160101.DeleteReplicationTaskAssessmentRun";

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

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

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

import Foundation

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

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

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

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=AmazonDMSv20160101.DescribeAccountAttributes" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeAccountAttributes"
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=AmazonDMSv20160101.DescribeAccountAttributes"),
    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=AmazonDMSv20160101.DescribeAccountAttributes");
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=AmazonDMSv20160101.DescribeAccountAttributes"

	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=AmazonDMSv20160101.DescribeAccountAttributes")
  .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=AmazonDMSv20160101.DescribeAccountAttributes"))
    .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=AmazonDMSv20160101.DescribeAccountAttributes")
  .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=AmazonDMSv20160101.DescribeAccountAttributes")
  .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=AmazonDMSv20160101.DescribeAccountAttributes');
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=AmazonDMSv20160101.DescribeAccountAttributes',
  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=AmazonDMSv20160101.DescribeAccountAttributes';
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=AmazonDMSv20160101.DescribeAccountAttributes',
  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=AmazonDMSv20160101.DescribeAccountAttributes")
  .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=AmazonDMSv20160101.DescribeAccountAttributes',
  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=AmazonDMSv20160101.DescribeAccountAttributes');

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=AmazonDMSv20160101.DescribeAccountAttributes',
  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=AmazonDMSv20160101.DescribeAccountAttributes';
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=AmazonDMSv20160101.DescribeAccountAttributes"]
                                                       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=AmazonDMSv20160101.DescribeAccountAttributes" 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=AmazonDMSv20160101.DescribeAccountAttributes",
  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=AmazonDMSv20160101.DescribeAccountAttributes', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeAccountAttributes');
$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=AmazonDMSv20160101.DescribeAccountAttributes');
$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=AmazonDMSv20160101.DescribeAccountAttributes' -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=AmazonDMSv20160101.DescribeAccountAttributes' -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=AmazonDMSv20160101.DescribeAccountAttributes"

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=AmazonDMSv20160101.DescribeAccountAttributes"

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=AmazonDMSv20160101.DescribeAccountAttributes")

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=AmazonDMSv20160101.DescribeAccountAttributes";

    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=AmazonDMSv20160101.DescribeAccountAttributes' \
  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=AmazonDMSv20160101.DescribeAccountAttributes'

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=AmazonDMSv20160101.DescribeAccountAttributes")! 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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments");

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  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:ReplicationTaskArn ""
                                                                                                                                   :ReplicationInstanceArn ""
                                                                                                                                   :SourceEngineName ""
                                                                                                                                   :TargetEngineName ""
                                                                                                                                   :MigrationType ""
                                                                                                                                   :MaxRecords ""
                                                                                                                                   :Marker ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments"

	payload := strings.NewReader("{\n  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 173

{
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  ReplicationTaskArn: '',
  ReplicationInstanceArn: '',
  SourceEngineName: '',
  TargetEngineName: '',
  MigrationType: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments');
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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationTaskArn: '',
    ReplicationInstanceArn: '',
    SourceEngineName: '',
    TargetEngineName: '',
    MigrationType: '',
    MaxRecords: '',
    Marker: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","ReplicationInstanceArn":"","SourceEngineName":"","TargetEngineName":"","MigrationType":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationTaskArn": "",\n  "ReplicationInstanceArn": "",\n  "SourceEngineName": "",\n  "TargetEngineName": "",\n  "MigrationType": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments")
  .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({
  ReplicationTaskArn: '',
  ReplicationInstanceArn: '',
  SourceEngineName: '',
  TargetEngineName: '',
  MigrationType: '',
  MaxRecords: '',
  Marker: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ReplicationTaskArn: '',
    ReplicationInstanceArn: '',
    SourceEngineName: '',
    TargetEngineName: '',
    MigrationType: '',
    MaxRecords: '',
    Marker: ''
  },
  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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments');

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

req.type('json');
req.send({
  ReplicationTaskArn: '',
  ReplicationInstanceArn: '',
  SourceEngineName: '',
  TargetEngineName: '',
  MigrationType: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ReplicationTaskArn: '',
    ReplicationInstanceArn: '',
    SourceEngineName: '',
    TargetEngineName: '',
    MigrationType: '',
    MaxRecords: '',
    Marker: ''
  }
};

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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","ReplicationInstanceArn":"","SourceEngineName":"","TargetEngineName":"","MigrationType":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"ReplicationTaskArn": @"",
                              @"ReplicationInstanceArn": @"",
                              @"SourceEngineName": @"",
                              @"TargetEngineName": @"",
                              @"MigrationType": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments",
  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([
    'ReplicationTaskArn' => '',
    'ReplicationInstanceArn' => '',
    'SourceEngineName' => '',
    'TargetEngineName' => '',
    'MigrationType' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments', [
  'body' => '{
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationTaskArn' => '',
  'ReplicationInstanceArn' => '',
  'SourceEngineName' => '',
  'TargetEngineName' => '',
  'MigrationType' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

append(json_encode([
  'ReplicationTaskArn' => '',
  'ReplicationInstanceArn' => '',
  'SourceEngineName' => '',
  'TargetEngineName' => '',
  'MigrationType' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments');
$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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

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

payload = "{\n  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments"

payload = {
    "ReplicationTaskArn": "",
    "ReplicationInstanceArn": "",
    "SourceEngineName": "",
    "TargetEngineName": "",
    "MigrationType": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments"

payload <- "{\n  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments")

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  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"ReplicationTaskArn\": \"\",\n  \"ReplicationInstanceArn\": \"\",\n  \"SourceEngineName\": \"\",\n  \"TargetEngineName\": \"\",\n  \"MigrationType\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeApplicableIndividualAssessments";

    let payload = json!({
        "ReplicationTaskArn": "",
        "ReplicationInstanceArn": "",
        "SourceEngineName": "",
        "TargetEngineName": "",
        "MigrationType": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationTaskArn": "",\n  "ReplicationInstanceArn": "",\n  "SourceEngineName": "",\n  "TargetEngineName": "",\n  "MigrationType": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeApplicableIndividualAssessments'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationTaskArn": "",
  "ReplicationInstanceArn": "",
  "SourceEngineName": "",
  "TargetEngineName": "",
  "MigrationType": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

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

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

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeCertificates" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:Filters ""
                                                                                                                :MaxRecords ""
                                                                                                                :Marker ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeCertificates"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

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

client.close();

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

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeCertificates');
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=AmazonDMSv20160101.DescribeCertificates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeCertificates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeCertificates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeCertificates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeCertificates"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeCertificates"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeCertificates")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeCertificates";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeCertificates' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeCertificates'

import Foundation

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

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

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

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeConnections" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Filters ""
                                                                                                               :MaxRecords ""
                                                                                                               :Marker ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeConnections"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

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

client.close();

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

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeConnections');
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=AmazonDMSv20160101.DescribeConnections',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeConnections';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeConnections',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeConnections';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeConnections"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeConnections"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeConnections")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeConnections";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeConnections' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeConnections'

import Foundation

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

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

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

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  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointSettings" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:EngineName ""
                                                                                                                    :MaxRecords ""
                                                                                                                    :Marker ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointSettings"

	payload := strings.NewReader("{\n  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")

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

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

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

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

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

}

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

{
  "EngineName": "",
  "MaxRecords": "",
  "Marker": ""
}

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

client.close();

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

const data = JSON.stringify({
  EngineName: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEndpointSettings');
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=AmazonDMSv20160101.DescribeEndpointSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EngineName: '', MaxRecords: '', Marker: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EngineName":"","MaxRecords":"","Marker":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  EngineName: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEndpointSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EngineName: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeEndpointSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EngineName":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"EngineName": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EngineName' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointSettings"

payload = {
    "EngineName": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeEndpointSettings"

payload <- "{\n  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointSettings")

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  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"EngineName\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointSettings";

    let payload = json!({
        "EngineName": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "EngineName": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EngineName": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointSettings'

import Foundation

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

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

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

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:Filters ""
                                                                                                                 :MaxRecords ""
                                                                                                                 :Marker ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

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

client.close();

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

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEndpointTypes');
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=AmazonDMSv20160101.DescribeEndpointTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEndpointTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeEndpointTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointTypes"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeEndpointTypes"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointTypes")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpointTypes";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpointTypes")! 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=AmazonDMSv20160101.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, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpoints" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:Filters ""
                                                                                                             :MaxRecords ""
                                                                                                             :Marker ""}})

require "http/client"

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

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

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

client.close();

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

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.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=AmazonDMSv20160101.DescribeEndpoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEndpoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeEndpoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpoints"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeEndpoints"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.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 = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEndpoints";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpoints' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEndpoints'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventCategories" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:SourceType ""
                                                                                                                   :Filters ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventCategories"

	payload := strings.NewReader("{\n  \"SourceType\": \"\",\n  \"Filters\": \"\"\n}")

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

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

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

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

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

}

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

{
  "SourceType": "",
  "Filters": ""
}

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

client.close();

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

const data = JSON.stringify({
  SourceType: '',
  Filters: ''
});

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=AmazonDMSv20160101.DescribeEventCategories');
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=AmazonDMSv20160101.DescribeEventCategories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SourceType: '', Filters: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  SourceType: '',
  Filters: ''
});

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=AmazonDMSv20160101.DescribeEventCategories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SourceType: '', Filters: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SourceType\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeEventCategories"

payload = {
    "SourceType": "",
    "Filters": ""
}
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=AmazonDMSv20160101.DescribeEventCategories"

payload <- "{\n  \"SourceType\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeEventCategories")

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  \"SourceType\": \"\",\n  \"Filters\": \"\"\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  \"SourceType\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeEventCategories";

    let payload = json!({
        "SourceType": "",
        "Filters": ""
    });

    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 '{
  "SourceType": "",
  "Filters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventCategories' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceType": "",\n  "Filters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventCategories'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SourceType": "",
  "Filters": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventCategories")! 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=AmazonDMSv20160101.DescribeEventSubscriptions");

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  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:SubscriptionName ""
                                                                                                                      :Filters ""
                                                                                                                      :MaxRecords ""
                                                                                                                      :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEventSubscriptions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEventSubscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions"

	payload := strings.NewReader("{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 81

{
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions")
  .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=AmazonDMSv20160101.DescribeEventSubscriptions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SubscriptionName: '',
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEventSubscriptions');
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=AmazonDMSv20160101.DescribeEventSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionName: '', Filters: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionName":"","Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeEventSubscriptions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SubscriptionName": "",\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions")
  .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({SubscriptionName: '', Filters: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {SubscriptionName: '', Filters: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeEventSubscriptions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SubscriptionName: '',
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEventSubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionName: '', Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeEventSubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionName":"","Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"SubscriptionName": @"",
                              @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions"]
                                                       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=AmazonDMSv20160101.DescribeEventSubscriptions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions",
  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([
    'SubscriptionName' => '',
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeEventSubscriptions', [
  'body' => '{
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SubscriptionName' => '',
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SubscriptionName' => '',
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions');
$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=AmazonDMSv20160101.DescribeEventSubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEventSubscriptions"

payload = {
    "SubscriptionName": "",
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeEventSubscriptions"

payload <- "{\n  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEventSubscriptions")

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  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"SubscriptionName\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEventSubscriptions";

    let payload = json!({
        "SubscriptionName": "",
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SubscriptionName": "",\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SubscriptionName": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEventSubscriptions")! 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=AmazonDMSv20160101.DescribeEvents");

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  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:SourceIdentifier ""
                                                                                                          :SourceType ""
                                                                                                          :StartTime ""
                                                                                                          :EndTime ""
                                                                                                          :Duration ""
                                                                                                          :EventCategories ""
                                                                                                          :Filters ""
                                                                                                          :MaxRecords ""
                                                                                                          :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEvents"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEvents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents"

	payload := strings.NewReader("{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 180

{
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents")
  .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=AmazonDMSv20160101.DescribeEvents")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SourceIdentifier: '',
  SourceType: '',
  StartTime: '',
  EndTime: '',
  Duration: '',
  EventCategories: '',
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEvents');
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=AmazonDMSv20160101.DescribeEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceIdentifier: '',
    SourceType: '',
    StartTime: '',
    EndTime: '',
    Duration: '',
    EventCategories: '',
    Filters: '',
    MaxRecords: '',
    Marker: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceIdentifier":"","SourceType":"","StartTime":"","EndTime":"","Duration":"","EventCategories":"","Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeEvents',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceIdentifier": "",\n  "SourceType": "",\n  "StartTime": "",\n  "EndTime": "",\n  "Duration": "",\n  "EventCategories": "",\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents")
  .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({
  SourceIdentifier: '',
  SourceType: '',
  StartTime: '',
  EndTime: '',
  Duration: '',
  EventCategories: '',
  Filters: '',
  MaxRecords: '',
  Marker: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SourceIdentifier: '',
    SourceType: '',
    StartTime: '',
    EndTime: '',
    Duration: '',
    EventCategories: '',
    Filters: '',
    MaxRecords: '',
    Marker: ''
  },
  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=AmazonDMSv20160101.DescribeEvents');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SourceIdentifier: '',
  SourceType: '',
  StartTime: '',
  EndTime: '',
  Duration: '',
  EventCategories: '',
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SourceIdentifier: '',
    SourceType: '',
    StartTime: '',
    EndTime: '',
    Duration: '',
    EventCategories: '',
    Filters: '',
    MaxRecords: '',
    Marker: ''
  }
};

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=AmazonDMSv20160101.DescribeEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SourceIdentifier":"","SourceType":"","StartTime":"","EndTime":"","Duration":"","EventCategories":"","Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"SourceIdentifier": @"",
                              @"SourceType": @"",
                              @"StartTime": @"",
                              @"EndTime": @"",
                              @"Duration": @"",
                              @"EventCategories": @"",
                              @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents"]
                                                       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=AmazonDMSv20160101.DescribeEvents" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents",
  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([
    'SourceIdentifier' => '',
    'SourceType' => '',
    'StartTime' => '',
    'EndTime' => '',
    'Duration' => '',
    'EventCategories' => '',
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeEvents', [
  'body' => '{
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceIdentifier' => '',
  'SourceType' => '',
  'StartTime' => '',
  'EndTime' => '',
  'Duration' => '',
  'EventCategories' => '',
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SourceIdentifier' => '',
  'SourceType' => '',
  'StartTime' => '',
  'EndTime' => '',
  'Duration' => '',
  'EventCategories' => '',
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents');
$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=AmazonDMSv20160101.DescribeEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEvents"

payload = {
    "SourceIdentifier": "",
    "SourceType": "",
    "StartTime": "",
    "EndTime": "",
    "Duration": "",
    "EventCategories": "",
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeEvents"

payload <- "{\n  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEvents")

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  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"SourceIdentifier\": \"\",\n  \"SourceType\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Duration\": \"\",\n  \"EventCategories\": \"\",\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeEvents";

    let payload = json!({
        "SourceIdentifier": "",
        "SourceType": "",
        "StartTime": "",
        "EndTime": "",
        "Duration": "",
        "EventCategories": "",
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceIdentifier": "",\n  "SourceType": "",\n  "StartTime": "",\n  "EndTime": "",\n  "Duration": "",\n  "EventCategories": "",\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SourceIdentifier": "",
  "SourceType": "",
  "StartTime": "",
  "EndTime": "",
  "Duration": "",
  "EventCategories": "",
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeEvents")! 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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:Filters ""
                                                                                                                          :MaxRecords ""
                                                                                                                          :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")
  .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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors');
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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"]
                                                       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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors');
$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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorCollectors";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorCollectors")! 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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:Filters ""
                                                                                                                         :MaxRecords ""
                                                                                                                         :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")
  .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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases');
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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"]
                                                       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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases');
$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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorDatabases";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorDatabases")! 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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis");

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  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:MaxRecords ""
                                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"

	payload := strings.NewReader("{\n  \"MaxRecords\": \"\",\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: 41

{
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MaxRecords\": \"\",\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  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")
  .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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis');
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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxRecords":"","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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxRecords": "",\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  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")
  .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({MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxRecords":"","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 = @{ @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"]
                                                       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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis",
  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([
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis', [
  'body' => '{
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis');
$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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"

payload = {
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis"

payload <- "{\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")

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  \"MaxRecords\": \"\",\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  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis";

    let payload = json!({
        "MaxRecords": "",
        "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 '{
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorLsaAnalysis")! 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:Filters ""
                                                                                                                                   :MaxRecords ""
                                                                                                                                   :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")
  .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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary');
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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"]
                                                       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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary');
$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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemaObjectSummary")! 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:Filters ""
                                                                                                                       :MaxRecords ""
                                                                                                                       :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")
  .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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas');
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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"]
                                                       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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas');
$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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeFleetAdvisorSchemas";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeFleetAdvisorSchemas")! 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=AmazonDMSv20160101.DescribeOrderableReplicationInstances");

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  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:MaxRecords ""
                                                                                                                                 :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeOrderableReplicationInstances"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeOrderableReplicationInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances"

	payload := strings.NewReader("{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances")
  .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=AmazonDMSv20160101.DescribeOrderableReplicationInstances")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeOrderableReplicationInstances');
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=AmazonDMSv20160101.DescribeOrderableReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeOrderableReplicationInstances',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances")
  .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({MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeOrderableReplicationInstances');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeOrderableReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeOrderableReplicationInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxRecords":"","Marker":""}'
};

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 = @{ @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances"]
                                                       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=AmazonDMSv20160101.DescribeOrderableReplicationInstances" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances",
  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([
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeOrderableReplicationInstances', [
  'body' => '{
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances');
$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=AmazonDMSv20160101.DescribeOrderableReplicationInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeOrderableReplicationInstances"

payload = {
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeOrderableReplicationInstances"

payload <- "{\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeOrderableReplicationInstances")

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  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeOrderableReplicationInstances";

    let payload = json!({
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeOrderableReplicationInstances")! 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=AmazonDMSv20160101.DescribePendingMaintenanceActions");

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  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:ReplicationInstanceArn ""
                                                                                                                             :Filters ""
                                                                                                                             :Marker ""
                                                                                                                             :MaxRecords ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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=AmazonDMSv20160101.DescribePendingMaintenanceActions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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=AmazonDMSv20160101.DescribePendingMaintenanceActions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions"

	payload := strings.NewReader("{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions")
  .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=AmazonDMSv20160101.DescribePendingMaintenanceActions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationInstanceArn: '',
  Filters: '',
  Marker: '',
  MaxRecords: ''
});

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=AmazonDMSv20160101.DescribePendingMaintenanceActions');
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=AmazonDMSv20160101.DescribePendingMaintenanceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', Filters: '', Marker: '', MaxRecords: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","Filters":"","Marker":"","MaxRecords":""}'
};

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=AmazonDMSv20160101.DescribePendingMaintenanceActions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationInstanceArn": "",\n  "Filters": "",\n  "Marker": "",\n  "MaxRecords": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions")
  .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({ReplicationInstanceArn: '', Filters: '', Marker: '', MaxRecords: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ReplicationInstanceArn: '', Filters: '', Marker: '', MaxRecords: ''},
  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=AmazonDMSv20160101.DescribePendingMaintenanceActions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReplicationInstanceArn: '',
  Filters: '',
  Marker: '',
  MaxRecords: ''
});

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=AmazonDMSv20160101.DescribePendingMaintenanceActions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', Filters: '', Marker: '', MaxRecords: ''}
};

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=AmazonDMSv20160101.DescribePendingMaintenanceActions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","Filters":"","Marker":"","MaxRecords":""}'
};

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 = @{ @"ReplicationInstanceArn": @"",
                              @"Filters": @"",
                              @"Marker": @"",
                              @"MaxRecords": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions"]
                                                       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=AmazonDMSv20160101.DescribePendingMaintenanceActions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions",
  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([
    'ReplicationInstanceArn' => '',
    'Filters' => '',
    'Marker' => '',
    'MaxRecords' => ''
  ]),
  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=AmazonDMSv20160101.DescribePendingMaintenanceActions', [
  'body' => '{
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationInstanceArn' => '',
  'Filters' => '',
  'Marker' => '',
  'MaxRecords' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReplicationInstanceArn' => '',
  'Filters' => '',
  'Marker' => '',
  'MaxRecords' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions');
$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=AmazonDMSv20160101.DescribePendingMaintenanceActions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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=AmazonDMSv20160101.DescribePendingMaintenanceActions"

payload = {
    "ReplicationInstanceArn": "",
    "Filters": "",
    "Marker": "",
    "MaxRecords": ""
}
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=AmazonDMSv20160101.DescribePendingMaintenanceActions"

payload <- "{\n  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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=AmazonDMSv20160101.DescribePendingMaintenanceActions")

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  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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  \"ReplicationInstanceArn\": \"\",\n  \"Filters\": \"\",\n  \"Marker\": \"\",\n  \"MaxRecords\": \"\"\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=AmazonDMSv20160101.DescribePendingMaintenanceActions";

    let payload = json!({
        "ReplicationInstanceArn": "",
        "Filters": "",
        "Marker": "",
        "MaxRecords": ""
    });

    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 '{
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationInstanceArn": "",\n  "Filters": "",\n  "Marker": "",\n  "MaxRecords": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationInstanceArn": "",
  "Filters": "",
  "Marker": "",
  "MaxRecords": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribePendingMaintenanceActions")! 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=AmazonDMSv20160101.DescribeRecommendationLimitations");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:Filters ""
                                                                                                                             :MaxRecords ""
                                                                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations")
  .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=AmazonDMSv20160101.DescribeRecommendationLimitations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeRecommendationLimitations');
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=AmazonDMSv20160101.DescribeRecommendationLimitations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeRecommendationLimitations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeRecommendationLimitations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeRecommendationLimitations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeRecommendationLimitations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations"]
                                                       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=AmazonDMSv20160101.DescribeRecommendationLimitations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeRecommendationLimitations', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations');
$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=AmazonDMSv20160101.DescribeRecommendationLimitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeRecommendationLimitations"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendationLimitations";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendationLimitations")! 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=AmazonDMSv20160101.DescribeRecommendations");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Filters ""
                                                                                                                   :MaxRecords ""
                                                                                                                   :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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: 58

{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations")
  .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=AmazonDMSv20160101.DescribeRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeRecommendations');
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=AmazonDMSv20160101.DescribeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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=AmazonDMSv20160101.DescribeRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations")
  .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({Filters: '', MaxRecords: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeRecommendations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  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=AmazonDMSv20160101.DescribeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', 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=AmazonDMSv20160101.DescribeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations"]
                                                       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=AmazonDMSv20160101.DescribeRecommendations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    '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=AmazonDMSv20160101.DescribeRecommendations', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations');
$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=AmazonDMSv20160101.DescribeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "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=AmazonDMSv20160101.DescribeRecommendations"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\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=AmazonDMSv20160101.DescribeRecommendations";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "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 '{
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRecommendations")! 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=AmazonDMSv20160101.DescribeRefreshSchemasStatus");

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  \"EndpointArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:EndpointArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DescribeRefreshSchemasStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DescribeRefreshSchemasStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus"

	payload := strings.NewReader("{\n  \"EndpointArn\": \"\"\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: 23

{
  "EndpointArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointArn\": \"\"\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  \"EndpointArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus")
  .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=AmazonDMSv20160101.DescribeRefreshSchemasStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointArn: ''
});

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=AmazonDMSv20160101.DescribeRefreshSchemasStatus');
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=AmazonDMSv20160101.DescribeRefreshSchemasStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointArn":""}'
};

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=AmazonDMSv20160101.DescribeRefreshSchemasStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus")
  .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({EndpointArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EndpointArn: ''},
  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=AmazonDMSv20160101.DescribeRefreshSchemasStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  EndpointArn: ''
});

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=AmazonDMSv20160101.DescribeRefreshSchemasStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointArn: ''}
};

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=AmazonDMSv20160101.DescribeRefreshSchemasStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointArn":""}'
};

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 = @{ @"EndpointArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus"]
                                                       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=AmazonDMSv20160101.DescribeRefreshSchemasStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus",
  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([
    'EndpointArn' => ''
  ]),
  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=AmazonDMSv20160101.DescribeRefreshSchemasStatus', [
  'body' => '{
  "EndpointArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'EndpointArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus');
$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=AmazonDMSv20160101.DescribeRefreshSchemasStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DescribeRefreshSchemasStatus"

payload = { "EndpointArn": "" }
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=AmazonDMSv20160101.DescribeRefreshSchemasStatus"

payload <- "{\n  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DescribeRefreshSchemasStatus")

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  \"EndpointArn\": \"\"\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  \"EndpointArn\": \"\"\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=AmazonDMSv20160101.DescribeRefreshSchemasStatus";

    let payload = json!({"EndpointArn": ""});

    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 '{
  "EndpointArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["EndpointArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeRefreshSchemasStatus")! 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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs");

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  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:ReplicationInstanceArn ""
                                                                                                                               :MaxRecords ""
                                                                                                                               :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"

	payload := strings.NewReader("{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")
  .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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationInstanceArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs');
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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationInstanceArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")
  .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({ReplicationInstanceArn: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ReplicationInstanceArn: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReplicationInstanceArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationInstanceArn: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationInstanceArn":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"ReplicationInstanceArn": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"]
                                                       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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs",
  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([
    'ReplicationInstanceArn' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs', [
  'body' => '{
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationInstanceArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReplicationInstanceArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs');
$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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"

payload = {
    "ReplicationInstanceArn": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs"

payload <- "{\n  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")

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  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"ReplicationInstanceArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs";

    let payload = json!({
        "ReplicationInstanceArn": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationInstanceArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationInstanceArn": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs")! 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=AmazonDMSv20160101.DescribeReplicationInstances");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:Filters ""
                                                                                                                        :MaxRecords ""
                                                                                                                        :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstances"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances")
  .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=AmazonDMSv20160101.DescribeReplicationInstances")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationInstances');
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=AmazonDMSv20160101.DescribeReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationInstances',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances")
  .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({Filters: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationInstances');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances"]
                                                       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=AmazonDMSv20160101.DescribeReplicationInstances" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationInstances', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances');
$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=AmazonDMSv20160101.DescribeReplicationInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstances"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationInstances"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstances")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationInstances";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationInstances")! 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=AmazonDMSv20160101.DescribeReplicationSubnetGroups");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:Filters ""
                                                                                                                           :MaxRecords ""
                                                                                                                           :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationSubnetGroups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationSubnetGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups")
  .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=AmazonDMSv20160101.DescribeReplicationSubnetGroups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationSubnetGroups');
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=AmazonDMSv20160101.DescribeReplicationSubnetGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationSubnetGroups',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups")
  .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({Filters: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationSubnetGroups');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationSubnetGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationSubnetGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups"]
                                                       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=AmazonDMSv20160101.DescribeReplicationSubnetGroups" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationSubnetGroups', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups');
$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=AmazonDMSv20160101.DescribeReplicationSubnetGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationSubnetGroups"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationSubnetGroups"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationSubnetGroups")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationSubnetGroups";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationSubnetGroups")! 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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults");

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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:ReplicationTaskArn ""
                                                                                                                                    :MaxRecords ""
                                                                                                                                    :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"

	payload := strings.NewReader("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")
  .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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationTaskArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults');
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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationTaskArn: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationTaskArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")
  .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({ReplicationTaskArn: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ReplicationTaskArn: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReplicationTaskArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationTaskArn: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"ReplicationTaskArn": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"]
                                                       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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults",
  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([
    'ReplicationTaskArn' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults', [
  'body' => '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationTaskArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReplicationTaskArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults');
$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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"

payload = {
    "ReplicationTaskArn": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults"

payload <- "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")

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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults";

    let payload = json!({
        "ReplicationTaskArn": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationTaskArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults")! 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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:Filters ""
                                                                                                                                 :MaxRecords ""
                                                                                                                                 :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")
  .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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns');
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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")
  .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({Filters: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"]
                                                       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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns');
$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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskAssessmentRuns")! 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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:Filters ""
                                                                                                                                        :MaxRecords ""
                                                                                                                                        :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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: 55

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")
  .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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments');
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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")
  .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({Filters: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"]
                                                       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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments');
$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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTaskIndividualAssessments")! 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=AmazonDMSv20160101.DescribeReplicationTasks");

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:Filters ""
                                                                                                                    :MaxRecords ""
                                                                                                                    :Marker ""
                                                                                                                    :WithoutSettings ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTasks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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: 80

{
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks")
  .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=AmazonDMSv20160101.DescribeReplicationTasks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxRecords: '',
  Marker: '',
  WithoutSettings: ''
});

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=AmazonDMSv20160101.DescribeReplicationTasks');
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=AmazonDMSv20160101.DescribeReplicationTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: '', WithoutSettings: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":"","WithoutSettings":""}'
};

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=AmazonDMSv20160101.DescribeReplicationTasks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": "",\n  "WithoutSettings": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks")
  .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({Filters: '', MaxRecords: '', Marker: '', WithoutSettings: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxRecords: '', Marker: '', WithoutSettings: ''},
  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=AmazonDMSv20160101.DescribeReplicationTasks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxRecords: '',
  Marker: '',
  WithoutSettings: ''
});

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=AmazonDMSv20160101.DescribeReplicationTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxRecords: '', Marker: '', WithoutSettings: ''}
};

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=AmazonDMSv20160101.DescribeReplicationTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxRecords":"","Marker":"","WithoutSettings":""}'
};

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 = @{ @"Filters": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"",
                              @"WithoutSettings": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks"]
                                                       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=AmazonDMSv20160101.DescribeReplicationTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks",
  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([
    'Filters' => '',
    'MaxRecords' => '',
    'Marker' => '',
    'WithoutSettings' => ''
  ]),
  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=AmazonDMSv20160101.DescribeReplicationTasks', [
  'body' => '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => '',
  'WithoutSettings' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxRecords' => '',
  'Marker' => '',
  'WithoutSettings' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks');
$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=AmazonDMSv20160101.DescribeReplicationTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTasks"

payload = {
    "Filters": "",
    "MaxRecords": "",
    "Marker": "",
    "WithoutSettings": ""
}
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=AmazonDMSv20160101.DescribeReplicationTasks"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTasks")

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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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  \"Filters\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"WithoutSettings\": \"\"\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=AmazonDMSv20160101.DescribeReplicationTasks";

    let payload = json!({
        "Filters": "",
        "MaxRecords": "",
        "Marker": "",
        "WithoutSettings": ""
    });

    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 '{
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": "",\n  "MaxRecords": "",\n  "Marker": "",\n  "WithoutSettings": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxRecords": "",
  "Marker": "",
  "WithoutSettings": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeReplicationTasks")! 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=AmazonDMSv20160101.DescribeSchemas");

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  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:EndpointArn ""
                                                                                                           :MaxRecords ""
                                                                                                           :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeSchemas"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeSchemas");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas"

	payload := strings.NewReader("{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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

{
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas")
  .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=AmazonDMSv20160101.DescribeSchemas")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EndpointArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeSchemas');
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=AmazonDMSv20160101.DescribeSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointArn: '', MaxRecords: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointArn":"","MaxRecords":"","Marker":""}'
};

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=AmazonDMSv20160101.DescribeSchemas',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EndpointArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas")
  .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({EndpointArn: '', MaxRecords: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EndpointArn: '', MaxRecords: '', Marker: ''},
  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=AmazonDMSv20160101.DescribeSchemas');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  EndpointArn: '',
  MaxRecords: '',
  Marker: ''
});

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=AmazonDMSv20160101.DescribeSchemas',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EndpointArn: '', MaxRecords: '', Marker: ''}
};

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=AmazonDMSv20160101.DescribeSchemas';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EndpointArn":"","MaxRecords":"","Marker":""}'
};

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 = @{ @"EndpointArn": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas"]
                                                       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=AmazonDMSv20160101.DescribeSchemas" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas",
  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([
    'EndpointArn' => '',
    'MaxRecords' => '',
    'Marker' => ''
  ]),
  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=AmazonDMSv20160101.DescribeSchemas', [
  'body' => '{
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EndpointArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'EndpointArn' => '',
  'MaxRecords' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas');
$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=AmazonDMSv20160101.DescribeSchemas' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeSchemas"

payload = {
    "EndpointArn": "",
    "MaxRecords": "",
    "Marker": ""
}
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=AmazonDMSv20160101.DescribeSchemas"

payload <- "{\n  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeSchemas")

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  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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  \"EndpointArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\"\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=AmazonDMSv20160101.DescribeSchemas";

    let payload = json!({
        "EndpointArn": "",
        "MaxRecords": "",
        "Marker": ""
    });

    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 '{
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EndpointArn": "",\n  "MaxRecords": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EndpointArn": "",
  "MaxRecords": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeSchemas")! 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=AmazonDMSv20160101.DescribeTableStatistics");

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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:ReplicationTaskArn ""
                                                                                                                   :MaxRecords ""
                                                                                                                   :Marker ""
                                                                                                                   :Filters ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeTableStatistics"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeTableStatistics");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics"

	payload := strings.NewReader("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 83

{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics")
  .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=AmazonDMSv20160101.DescribeTableStatistics")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ReplicationTaskArn: '',
  MaxRecords: '',
  Marker: '',
  Filters: ''
});

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=AmazonDMSv20160101.DescribeTableStatistics');
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=AmazonDMSv20160101.DescribeTableStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationTaskArn: '', MaxRecords: '', Marker: '', Filters: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","MaxRecords":"","Marker":"","Filters":""}'
};

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=AmazonDMSv20160101.DescribeTableStatistics',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReplicationTaskArn": "",\n  "MaxRecords": "",\n  "Marker": "",\n  "Filters": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics")
  .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({ReplicationTaskArn: '', MaxRecords: '', Marker: '', Filters: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ReplicationTaskArn: '', MaxRecords: '', Marker: '', Filters: ''},
  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=AmazonDMSv20160101.DescribeTableStatistics');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReplicationTaskArn: '',
  MaxRecords: '',
  Marker: '',
  Filters: ''
});

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=AmazonDMSv20160101.DescribeTableStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ReplicationTaskArn: '', MaxRecords: '', Marker: '', Filters: ''}
};

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=AmazonDMSv20160101.DescribeTableStatistics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ReplicationTaskArn":"","MaxRecords":"","Marker":"","Filters":""}'
};

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 = @{ @"ReplicationTaskArn": @"",
                              @"MaxRecords": @"",
                              @"Marker": @"",
                              @"Filters": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics"]
                                                       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=AmazonDMSv20160101.DescribeTableStatistics" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics",
  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([
    'ReplicationTaskArn' => '',
    'MaxRecords' => '',
    'Marker' => '',
    'Filters' => ''
  ]),
  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=AmazonDMSv20160101.DescribeTableStatistics', [
  'body' => '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReplicationTaskArn' => '',
  'MaxRecords' => '',
  'Marker' => '',
  'Filters' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReplicationTaskArn' => '',
  'MaxRecords' => '',
  'Marker' => '',
  'Filters' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics');
$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=AmazonDMSv20160101.DescribeTableStatistics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeTableStatistics"

payload = {
    "ReplicationTaskArn": "",
    "MaxRecords": "",
    "Marker": "",
    "Filters": ""
}
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=AmazonDMSv20160101.DescribeTableStatistics"

payload <- "{\n  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeTableStatistics")

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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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  \"ReplicationTaskArn\": \"\",\n  \"MaxRecords\": \"\",\n  \"Marker\": \"\",\n  \"Filters\": \"\"\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=AmazonDMSv20160101.DescribeTableStatistics";

    let payload = json!({
        "ReplicationTaskArn": "",
        "MaxRecords": "",
        "Marker": "",
        "Filters": ""
    });

    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 '{
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReplicationTaskArn": "",\n  "MaxRecords": "",\n  "Marker": "",\n  "Filters": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ReplicationTaskArn": "",
  "MaxRecords": "",
  "Marker": "",
  "Filters": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.DescribeTableStatistics")! 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=AmazonDMSv20160101.ImportCertificate");

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  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:CertificateIdentifier ""
                                                                                                             :CertificatePem ""
                                                                                                             :CertificateWallet ""
                                                                                                             :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate"

	payload := strings.NewReader("{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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: 98

{
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate")
  .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=AmazonDMSv20160101.ImportCertificate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CertificateIdentifier: '',
  CertificatePem: '',
  CertificateWallet: '',
  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=AmazonDMSv20160101.ImportCertificate');
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=AmazonDMSv20160101.ImportCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CertificateIdentifier: '', CertificatePem: '', CertificateWallet: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CertificateIdentifier":"","CertificatePem":"","CertificateWallet":"","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=AmazonDMSv20160101.ImportCertificate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CertificateIdentifier": "",\n  "CertificatePem": "",\n  "CertificateWallet": "",\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  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate")
  .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({CertificateIdentifier: '', CertificatePem: '', CertificateWallet: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {CertificateIdentifier: '', CertificatePem: '', CertificateWallet: '', 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=AmazonDMSv20160101.ImportCertificate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CertificateIdentifier: '',
  CertificatePem: '',
  CertificateWallet: '',
  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=AmazonDMSv20160101.ImportCertificate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CertificateIdentifier: '', CertificatePem: '', CertificateWallet: '', 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=AmazonDMSv20160101.ImportCertificate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CertificateIdentifier":"","CertificatePem":"","CertificateWallet":"","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 = @{ @"CertificateIdentifier": @"",
                              @"CertificatePem": @"",
                              @"CertificateWallet": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate"]
                                                       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=AmazonDMSv20160101.ImportCertificate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate",
  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([
    'CertificateIdentifier' => '',
    'CertificatePem' => '',
    'CertificateWallet' => '',
    '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=AmazonDMSv20160101.ImportCertificate', [
  'body' => '{
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CertificateIdentifier' => '',
  'CertificatePem' => '',
  'CertificateWallet' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CertificateIdentifier' => '',
  'CertificatePem' => '',
  'CertificateWallet' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate');
$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=AmazonDMSv20160101.ImportCertificate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate"

payload = {
    "CertificateIdentifier": "",
    "CertificatePem": "",
    "CertificateWallet": "",
    "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=AmazonDMSv20160101.ImportCertificate"

payload <- "{\n  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate")

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  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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  \"CertificateIdentifier\": \"\",\n  \"CertificatePem\": \"\",\n  \"CertificateWallet\": \"\",\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=AmazonDMSv20160101.ImportCertificate";

    let payload = json!({
        "CertificateIdentifier": "",
        "CertificatePem": "",
        "CertificateWallet": "",
        "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 '{
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CertificateIdentifier": "",\n  "CertificatePem": "",\n  "CertificateWallet": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CertificateIdentifier": "",
  "CertificatePem": "",
  "CertificateWallet": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ImportCertificate")! 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=AmazonDMSv20160101.ListTagsForResource");

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  \"ResourceArnList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:ResourceArn ""
                                                                                                               :ResourceArnList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\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=AmazonDMSv20160101.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\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=AmazonDMSv20160101.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 48

{
  "ResourceArn": "",
  "ResourceArnList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\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  \"ResourceArnList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonDMSv20160101.ListTagsForResource")
  .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=AmazonDMSv20160101.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"ResourceArnList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  ResourceArnList: ''
});

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=AmazonDMSv20160101.ListTagsForResource');
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=AmazonDMSv20160101.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourceArnList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}