Amazon Simple Systems Manager (SSM)v2014-11-06

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AmazonSSM.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  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.AddTagsToResource" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:ResourceType ""
                                                                                                    :ResourceId ""
                                                                                                    :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\n  \"Tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ResourceType": "",
  "ResourceId": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ResourceType: '',
  ResourceId: '',
  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=AmazonSSM.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=AmazonSSM.AddTagsToResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceType: '', ResourceId: '', Tags: ''}
};

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

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

const request = require('request');

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

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.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=AmazonSSM.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  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\n  \"Tags\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceType' => '',
  'ResourceId' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\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=AmazonSSM.AddTagsToResource"

payload = {
    "ResourceType": "",
    "ResourceId": "",
    "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=AmazonSSM.AddTagsToResource"

payload <- "{\n  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\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=AmazonSSM.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  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\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  \"ResourceType\": \"\",\n  \"ResourceId\": \"\",\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=AmazonSSM.AddTagsToResource";

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

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceType": "",\n  "ResourceId": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.AddTagsToResource'

import Foundation

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

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

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

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  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.AssociateOpsItemRelatedItem" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:OpsItemId ""
                                                                                                              :AssociationType ""
                                                                                                              :ResourceType ""
                                                                                                              :ResourceUri ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.AssociateOpsItemRelatedItem"

	payload := strings.NewReader("{\n  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\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: 89

{
  "OpsItemId": "",
  "AssociationType": "",
  "ResourceType": "",
  "ResourceUri": ""
}

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

client.close();

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

const data = JSON.stringify({
  OpsItemId: '',
  AssociationType: '',
  ResourceType: '',
  ResourceUri: ''
});

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=AmazonSSM.AssociateOpsItemRelatedItem');
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=AmazonSSM.AssociateOpsItemRelatedItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {OpsItemId: '', AssociationType: '', ResourceType: '', ResourceUri: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.AssociateOpsItemRelatedItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"OpsItemId":"","AssociationType":"","ResourceType":"","ResourceUri":""}'
};

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=AmazonSSM.AssociateOpsItemRelatedItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "OpsItemId": "",\n  "AssociationType": "",\n  "ResourceType": "",\n  "ResourceUri": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  OpsItemId: '',
  AssociationType: '',
  ResourceType: '',
  ResourceUri: ''
});

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=AmazonSSM.AssociateOpsItemRelatedItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {OpsItemId: '', AssociationType: '', ResourceType: '', ResourceUri: ''}
};

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=AmazonSSM.AssociateOpsItemRelatedItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"OpsItemId":"","AssociationType":"","ResourceType":"","ResourceUri":""}'
};

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 = @{ @"OpsItemId": @"",
                              @"AssociationType": @"",
                              @"ResourceType": @"",
                              @"ResourceUri": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'OpsItemId' => '',
  'AssociationType' => '',
  'ResourceType' => '',
  'ResourceUri' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\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=AmazonSSM.AssociateOpsItemRelatedItem"

payload = {
    "OpsItemId": "",
    "AssociationType": "",
    "ResourceType": "",
    "ResourceUri": ""
}
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=AmazonSSM.AssociateOpsItemRelatedItem"

payload <- "{\n  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\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=AmazonSSM.AssociateOpsItemRelatedItem")

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  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\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  \"OpsItemId\": \"\",\n  \"AssociationType\": \"\",\n  \"ResourceType\": \"\",\n  \"ResourceUri\": \"\"\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=AmazonSSM.AssociateOpsItemRelatedItem";

    let payload = json!({
        "OpsItemId": "",
        "AssociationType": "",
        "ResourceType": "",
        "ResourceUri": ""
    });

    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 '{
  "OpsItemId": "",
  "AssociationType": "",
  "ResourceType": "",
  "ResourceUri": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.AssociateOpsItemRelatedItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "OpsItemId": "",\n  "AssociationType": "",\n  "ResourceType": "",\n  "ResourceUri": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.AssociateOpsItemRelatedItem'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CancelCommand" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:CommandId ""
                                                                                                :InstanceIds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CancelCommand"

	payload := strings.NewReader("{\n  \"CommandId\": \"\",\n  \"InstanceIds\": \"\"\n}")

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

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

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

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

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

}

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

{
  "CommandId": "",
  "InstanceIds": ""
}

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

client.close();

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

const data = JSON.stringify({
  CommandId: '',
  InstanceIds: ''
});

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=AmazonSSM.CancelCommand');
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=AmazonSSM.CancelCommand',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CommandId: '', InstanceIds: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  CommandId: '',
  InstanceIds: ''
});

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=AmazonSSM.CancelCommand',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CommandId: '', InstanceIds: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"CommandId\": \"\",\n  \"InstanceIds\": \"\"\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=AmazonSSM.CancelCommand"

payload = {
    "CommandId": "",
    "InstanceIds": ""
}
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=AmazonSSM.CancelCommand"

payload <- "{\n  \"CommandId\": \"\",\n  \"InstanceIds\": \"\"\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=AmazonSSM.CancelCommand")

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  \"CommandId\": \"\",\n  \"InstanceIds\": \"\"\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  \"CommandId\": \"\",\n  \"InstanceIds\": \"\"\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=AmazonSSM.CancelCommand";

    let payload = json!({
        "CommandId": "",
        "InstanceIds": ""
    });

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CancelMaintenanceWindowExecution"

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

{
  "WindowExecutionId": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"WindowExecutionId\": \"\"\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=AmazonSSM.CancelMaintenanceWindowExecution"

payload = { "WindowExecutionId": "" }
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=AmazonSSM.CancelMaintenanceWindowExecution"

payload <- "{\n  \"WindowExecutionId\": \"\"\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=AmazonSSM.CancelMaintenanceWindowExecution")

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  \"WindowExecutionId\": \"\"\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  \"WindowExecutionId\": \"\"\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=AmazonSSM.CancelMaintenanceWindowExecution";

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

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

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

import Foundation

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

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

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

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  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation" {:headers {:x-amz-target ""}
                                                                                     :content-type :json
                                                                                     :form-params {:Description ""
                                                                                                   :DefaultInstanceName ""
                                                                                                   :IamRole ""
                                                                                                   :RegistrationLimit ""
                                                                                                   :ExpirationDate ""
                                                                                                   :Tags ""
                                                                                                   :RegistrationMetadata ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\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: 164

{
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  Description: '',
  DefaultInstanceName: '',
  IamRole: '',
  RegistrationLimit: '',
  ExpirationDate: '',
  Tags: '',
  RegistrationMetadata: ''
});

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=AmazonSSM.CreateActivation');
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=AmazonSSM.CreateActivation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Description: '',
    DefaultInstanceName: '',
    IamRole: '',
    RegistrationLimit: '',
    ExpirationDate: '',
    Tags: '',
    RegistrationMetadata: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Description":"","DefaultInstanceName":"","IamRole":"","RegistrationLimit":"","ExpirationDate":"","Tags":"","RegistrationMetadata":""}'
};

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=AmazonSSM.CreateActivation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "DefaultInstanceName": "",\n  "IamRole": "",\n  "RegistrationLimit": "",\n  "ExpirationDate": "",\n  "Tags": "",\n  "RegistrationMetadata": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation")
  .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({
  Description: '',
  DefaultInstanceName: '',
  IamRole: '',
  RegistrationLimit: '',
  ExpirationDate: '',
  Tags: '',
  RegistrationMetadata: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Description: '',
    DefaultInstanceName: '',
    IamRole: '',
    RegistrationLimit: '',
    ExpirationDate: '',
    Tags: '',
    RegistrationMetadata: ''
  },
  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=AmazonSSM.CreateActivation');

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

req.type('json');
req.send({
  Description: '',
  DefaultInstanceName: '',
  IamRole: '',
  RegistrationLimit: '',
  ExpirationDate: '',
  Tags: '',
  RegistrationMetadata: ''
});

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=AmazonSSM.CreateActivation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Description: '',
    DefaultInstanceName: '',
    IamRole: '',
    RegistrationLimit: '',
    ExpirationDate: '',
    Tags: '',
    RegistrationMetadata: ''
  }
};

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=AmazonSSM.CreateActivation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Description":"","DefaultInstanceName":"","IamRole":"","RegistrationLimit":"","ExpirationDate":"","Tags":"","RegistrationMetadata":""}'
};

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 = @{ @"Description": @"",
                              @"DefaultInstanceName": @"",
                              @"IamRole": @"",
                              @"RegistrationLimit": @"",
                              @"ExpirationDate": @"",
                              @"Tags": @"",
                              @"RegistrationMetadata": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation",
  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([
    'Description' => '',
    'DefaultInstanceName' => '',
    'IamRole' => '',
    'RegistrationLimit' => '',
    'ExpirationDate' => '',
    'Tags' => '',
    'RegistrationMetadata' => ''
  ]),
  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=AmazonSSM.CreateActivation', [
  'body' => '{
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'DefaultInstanceName' => '',
  'IamRole' => '',
  'RegistrationLimit' => '',
  'ExpirationDate' => '',
  'Tags' => '',
  'RegistrationMetadata' => ''
]));

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

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

append(json_encode([
  'Description' => '',
  'DefaultInstanceName' => '',
  'IamRole' => '',
  'RegistrationLimit' => '',
  'ExpirationDate' => '',
  'Tags' => '',
  'RegistrationMetadata' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation');
$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=AmazonSSM.CreateActivation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
}'

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\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=AmazonSSM.CreateActivation"

payload = {
    "Description": "",
    "DefaultInstanceName": "",
    "IamRole": "",
    "RegistrationLimit": "",
    "ExpirationDate": "",
    "Tags": "",
    "RegistrationMetadata": ""
}
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=AmazonSSM.CreateActivation"

payload <- "{\n  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\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=AmazonSSM.CreateActivation")

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  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\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  \"Description\": \"\",\n  \"DefaultInstanceName\": \"\",\n  \"IamRole\": \"\",\n  \"RegistrationLimit\": \"\",\n  \"ExpirationDate\": \"\",\n  \"Tags\": \"\",\n  \"RegistrationMetadata\": \"\"\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=AmazonSSM.CreateActivation";

    let payload = json!({
        "Description": "",
        "DefaultInstanceName": "",
        "IamRole": "",
        "RegistrationLimit": "",
        "ExpirationDate": "",
        "Tags": "",
        "RegistrationMetadata": ""
    });

    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 '{
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "DefaultInstanceName": "",\n  "IamRole": "",\n  "RegistrationLimit": "",\n  "ExpirationDate": "",\n  "Tags": "",\n  "RegistrationMetadata": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateActivation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Description": "",
  "DefaultInstanceName": "",
  "IamRole": "",
  "RegistrationLimit": "",
  "ExpirationDate": "",
  "Tags": "",
  "RegistrationMetadata": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:Name ""
                                                                                                    :DocumentVersion ""
                                                                                                    :InstanceId ""
                                                                                                    :Parameters ""
                                                                                                    :Targets ""
                                                                                                    :ScheduleExpression ""
                                                                                                    :OutputLocation ""
                                                                                                    :AssociationName ""
                                                                                                    :AutomationTargetParameterName ""
                                                                                                    :MaxErrors ""
                                                                                                    :MaxConcurrency ""
                                                                                                    :ComplianceSeverity ""
                                                                                                    :SyncCompliance ""
                                                                                                    :ApplyOnlyAtCronInterval ""
                                                                                                    :CalendarNames ""
                                                                                                    :TargetLocations ""
                                                                                                    :ScheduleOffset ""
                                                                                                    :TargetMaps ""
                                                                                                    :Tags ""
                                                                                                    :AlarmConfiguration {:IgnorePollAlarmFailure ""
                                                                                                                         :Alarms ""}}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\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: 530

{
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": {
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation")
  .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=AmazonSSM.CreateAssociation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  DocumentVersion: '',
  InstanceId: '',
  Parameters: '',
  Targets: '',
  ScheduleExpression: '',
  OutputLocation: '',
  AssociationName: '',
  AutomationTargetParameterName: '',
  MaxErrors: '',
  MaxConcurrency: '',
  ComplianceSeverity: '',
  SyncCompliance: '',
  ApplyOnlyAtCronInterval: '',
  CalendarNames: '',
  TargetLocations: '',
  ScheduleOffset: '',
  TargetMaps: '',
  Tags: '',
  AlarmConfiguration: {
    IgnorePollAlarmFailure: '',
    Alarms: ''
  }
});

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=AmazonSSM.CreateAssociation');
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=AmazonSSM.CreateAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DocumentVersion: '',
    InstanceId: '',
    Parameters: '',
    Targets: '',
    ScheduleExpression: '',
    OutputLocation: '',
    AssociationName: '',
    AutomationTargetParameterName: '',
    MaxErrors: '',
    MaxConcurrency: '',
    ComplianceSeverity: '',
    SyncCompliance: '',
    ApplyOnlyAtCronInterval: '',
    CalendarNames: '',
    TargetLocations: '',
    ScheduleOffset: '',
    TargetMaps: '',
    Tags: '',
    AlarmConfiguration: {IgnorePollAlarmFailure: '', Alarms: ''}
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","InstanceId":"","Parameters":"","Targets":"","ScheduleExpression":"","OutputLocation":"","AssociationName":"","AutomationTargetParameterName":"","MaxErrors":"","MaxConcurrency":"","ComplianceSeverity":"","SyncCompliance":"","ApplyOnlyAtCronInterval":"","CalendarNames":"","TargetLocations":"","ScheduleOffset":"","TargetMaps":"","Tags":"","AlarmConfiguration":{"IgnorePollAlarmFailure":"","Alarms":""}}'
};

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=AmazonSSM.CreateAssociation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DocumentVersion": "",\n  "InstanceId": "",\n  "Parameters": "",\n  "Targets": "",\n  "ScheduleExpression": "",\n  "OutputLocation": "",\n  "AssociationName": "",\n  "AutomationTargetParameterName": "",\n  "MaxErrors": "",\n  "MaxConcurrency": "",\n  "ComplianceSeverity": "",\n  "SyncCompliance": "",\n  "ApplyOnlyAtCronInterval": "",\n  "CalendarNames": "",\n  "TargetLocations": "",\n  "ScheduleOffset": "",\n  "TargetMaps": "",\n  "Tags": "",\n  "AlarmConfiguration": {\n    "IgnorePollAlarmFailure": "",\n    "Alarms": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  DocumentVersion: '',
  InstanceId: '',
  Parameters: '',
  Targets: '',
  ScheduleExpression: '',
  OutputLocation: '',
  AssociationName: '',
  AutomationTargetParameterName: '',
  MaxErrors: '',
  MaxConcurrency: '',
  ComplianceSeverity: '',
  SyncCompliance: '',
  ApplyOnlyAtCronInterval: '',
  CalendarNames: '',
  TargetLocations: '',
  ScheduleOffset: '',
  TargetMaps: '',
  Tags: '',
  AlarmConfiguration: {IgnorePollAlarmFailure: '', Alarms: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    DocumentVersion: '',
    InstanceId: '',
    Parameters: '',
    Targets: '',
    ScheduleExpression: '',
    OutputLocation: '',
    AssociationName: '',
    AutomationTargetParameterName: '',
    MaxErrors: '',
    MaxConcurrency: '',
    ComplianceSeverity: '',
    SyncCompliance: '',
    ApplyOnlyAtCronInterval: '',
    CalendarNames: '',
    TargetLocations: '',
    ScheduleOffset: '',
    TargetMaps: '',
    Tags: '',
    AlarmConfiguration: {IgnorePollAlarmFailure: '', Alarms: ''}
  },
  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=AmazonSSM.CreateAssociation');

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

req.type('json');
req.send({
  Name: '',
  DocumentVersion: '',
  InstanceId: '',
  Parameters: '',
  Targets: '',
  ScheduleExpression: '',
  OutputLocation: '',
  AssociationName: '',
  AutomationTargetParameterName: '',
  MaxErrors: '',
  MaxConcurrency: '',
  ComplianceSeverity: '',
  SyncCompliance: '',
  ApplyOnlyAtCronInterval: '',
  CalendarNames: '',
  TargetLocations: '',
  ScheduleOffset: '',
  TargetMaps: '',
  Tags: '',
  AlarmConfiguration: {
    IgnorePollAlarmFailure: '',
    Alarms: ''
  }
});

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=AmazonSSM.CreateAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    DocumentVersion: '',
    InstanceId: '',
    Parameters: '',
    Targets: '',
    ScheduleExpression: '',
    OutputLocation: '',
    AssociationName: '',
    AutomationTargetParameterName: '',
    MaxErrors: '',
    MaxConcurrency: '',
    ComplianceSeverity: '',
    SyncCompliance: '',
    ApplyOnlyAtCronInterval: '',
    CalendarNames: '',
    TargetLocations: '',
    ScheduleOffset: '',
    TargetMaps: '',
    Tags: '',
    AlarmConfiguration: {IgnorePollAlarmFailure: '', Alarms: ''}
  }
};

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=AmazonSSM.CreateAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","InstanceId":"","Parameters":"","Targets":"","ScheduleExpression":"","OutputLocation":"","AssociationName":"","AutomationTargetParameterName":"","MaxErrors":"","MaxConcurrency":"","ComplianceSeverity":"","SyncCompliance":"","ApplyOnlyAtCronInterval":"","CalendarNames":"","TargetLocations":"","ScheduleOffset":"","TargetMaps":"","Tags":"","AlarmConfiguration":{"IgnorePollAlarmFailure":"","Alarms":""}}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"DocumentVersion": @"",
                              @"InstanceId": @"",
                              @"Parameters": @"",
                              @"Targets": @"",
                              @"ScheduleExpression": @"",
                              @"OutputLocation": @"",
                              @"AssociationName": @"",
                              @"AutomationTargetParameterName": @"",
                              @"MaxErrors": @"",
                              @"MaxConcurrency": @"",
                              @"ComplianceSeverity": @"",
                              @"SyncCompliance": @"",
                              @"ApplyOnlyAtCronInterval": @"",
                              @"CalendarNames": @"",
                              @"TargetLocations": @"",
                              @"ScheduleOffset": @"",
                              @"TargetMaps": @"",
                              @"Tags": @"",
                              @"AlarmConfiguration": @{ @"IgnorePollAlarmFailure": @"", @"Alarms": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation"]
                                                       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=AmazonSSM.CreateAssociation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'DocumentVersion' => '',
    'InstanceId' => '',
    'Parameters' => '',
    'Targets' => '',
    'ScheduleExpression' => '',
    'OutputLocation' => '',
    'AssociationName' => '',
    'AutomationTargetParameterName' => '',
    'MaxErrors' => '',
    'MaxConcurrency' => '',
    'ComplianceSeverity' => '',
    'SyncCompliance' => '',
    'ApplyOnlyAtCronInterval' => '',
    'CalendarNames' => '',
    'TargetLocations' => '',
    'ScheduleOffset' => '',
    'TargetMaps' => '',
    'Tags' => '',
    'AlarmConfiguration' => [
        'IgnorePollAlarmFailure' => '',
        'Alarms' => ''
    ]
  ]),
  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=AmazonSSM.CreateAssociation', [
  'body' => '{
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": {
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DocumentVersion' => '',
  'InstanceId' => '',
  'Parameters' => '',
  'Targets' => '',
  'ScheduleExpression' => '',
  'OutputLocation' => '',
  'AssociationName' => '',
  'AutomationTargetParameterName' => '',
  'MaxErrors' => '',
  'MaxConcurrency' => '',
  'ComplianceSeverity' => '',
  'SyncCompliance' => '',
  'ApplyOnlyAtCronInterval' => '',
  'CalendarNames' => '',
  'TargetLocations' => '',
  'ScheduleOffset' => '',
  'TargetMaps' => '',
  'Tags' => '',
  'AlarmConfiguration' => [
    'IgnorePollAlarmFailure' => '',
    'Alarms' => ''
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'DocumentVersion' => '',
  'InstanceId' => '',
  'Parameters' => '',
  'Targets' => '',
  'ScheduleExpression' => '',
  'OutputLocation' => '',
  'AssociationName' => '',
  'AutomationTargetParameterName' => '',
  'MaxErrors' => '',
  'MaxConcurrency' => '',
  'ComplianceSeverity' => '',
  'SyncCompliance' => '',
  'ApplyOnlyAtCronInterval' => '',
  'CalendarNames' => '',
  'TargetLocations' => '',
  'ScheduleOffset' => '',
  'TargetMaps' => '',
  'Tags' => '',
  'AlarmConfiguration' => [
    'IgnorePollAlarmFailure' => '',
    'Alarms' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation');
$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=AmazonSSM.CreateAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": {
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  }
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": {
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\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=AmazonSSM.CreateAssociation"

payload = {
    "Name": "",
    "DocumentVersion": "",
    "InstanceId": "",
    "Parameters": "",
    "Targets": "",
    "ScheduleExpression": "",
    "OutputLocation": "",
    "AssociationName": "",
    "AutomationTargetParameterName": "",
    "MaxErrors": "",
    "MaxConcurrency": "",
    "ComplianceSeverity": "",
    "SyncCompliance": "",
    "ApplyOnlyAtCronInterval": "",
    "CalendarNames": "",
    "TargetLocations": "",
    "ScheduleOffset": "",
    "TargetMaps": "",
    "Tags": "",
    "AlarmConfiguration": {
        "IgnorePollAlarmFailure": "",
        "Alarms": ""
    }
}
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=AmazonSSM.CreateAssociation"

payload <- "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\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=AmazonSSM.CreateAssociation")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"InstanceId\": \"\",\n  \"Parameters\": \"\",\n  \"Targets\": \"\",\n  \"ScheduleExpression\": \"\",\n  \"OutputLocation\": \"\",\n  \"AssociationName\": \"\",\n  \"AutomationTargetParameterName\": \"\",\n  \"MaxErrors\": \"\",\n  \"MaxConcurrency\": \"\",\n  \"ComplianceSeverity\": \"\",\n  \"SyncCompliance\": \"\",\n  \"ApplyOnlyAtCronInterval\": \"\",\n  \"CalendarNames\": \"\",\n  \"TargetLocations\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"TargetMaps\": \"\",\n  \"Tags\": \"\",\n  \"AlarmConfiguration\": {\n    \"IgnorePollAlarmFailure\": \"\",\n    \"Alarms\": \"\"\n  }\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=AmazonSSM.CreateAssociation";

    let payload = json!({
        "Name": "",
        "DocumentVersion": "",
        "InstanceId": "",
        "Parameters": "",
        "Targets": "",
        "ScheduleExpression": "",
        "OutputLocation": "",
        "AssociationName": "",
        "AutomationTargetParameterName": "",
        "MaxErrors": "",
        "MaxConcurrency": "",
        "ComplianceSeverity": "",
        "SyncCompliance": "",
        "ApplyOnlyAtCronInterval": "",
        "CalendarNames": "",
        "TargetLocations": "",
        "ScheduleOffset": "",
        "TargetMaps": "",
        "Tags": "",
        "AlarmConfiguration": json!({
            "IgnorePollAlarmFailure": "",
            "Alarms": ""
        })
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": {
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  }
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DocumentVersion": "",\n  "InstanceId": "",\n  "Parameters": "",\n  "Targets": "",\n  "ScheduleExpression": "",\n  "OutputLocation": "",\n  "AssociationName": "",\n  "AutomationTargetParameterName": "",\n  "MaxErrors": "",\n  "MaxConcurrency": "",\n  "ComplianceSeverity": "",\n  "SyncCompliance": "",\n  "ApplyOnlyAtCronInterval": "",\n  "CalendarNames": "",\n  "TargetLocations": "",\n  "ScheduleOffset": "",\n  "TargetMaps": "",\n  "Tags": "",\n  "AlarmConfiguration": {\n    "IgnorePollAlarmFailure": "",\n    "Alarms": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "DocumentVersion": "",
  "InstanceId": "",
  "Parameters": "",
  "Targets": "",
  "ScheduleExpression": "",
  "OutputLocation": "",
  "AssociationName": "",
  "AutomationTargetParameterName": "",
  "MaxErrors": "",
  "MaxConcurrency": "",
  "ComplianceSeverity": "",
  "SyncCompliance": "",
  "ApplyOnlyAtCronInterval": "",
  "CalendarNames": "",
  "TargetLocations": "",
  "ScheduleOffset": "",
  "TargetMaps": "",
  "Tags": "",
  "AlarmConfiguration": [
    "IgnorePollAlarmFailure": "",
    "Alarms": ""
  ]
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociationBatch"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Entries\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociationBatch"

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

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

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

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

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

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

}

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

{
  "Entries": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociationBatch"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateAssociationBatch"

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

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"Entries\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

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

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  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:Content ""
                                                                                                 :Requires ""
                                                                                                 :Attachments ""
                                                                                                 :Name ""
                                                                                                 :DisplayName ""
                                                                                                 :VersionName ""
                                                                                                 :DocumentType ""
                                                                                                 :DocumentFormat ""
                                                                                                 :TargetType ""
                                                                                                 :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument"

	payload := strings.NewReader("{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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: 194

{
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument")
  .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=AmazonSSM.CreateDocument")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Content: '',
  Requires: '',
  Attachments: '',
  Name: '',
  DisplayName: '',
  VersionName: '',
  DocumentType: '',
  DocumentFormat: '',
  TargetType: '',
  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=AmazonSSM.CreateDocument');
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=AmazonSSM.CreateDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Content: '',
    Requires: '',
    Attachments: '',
    Name: '',
    DisplayName: '',
    VersionName: '',
    DocumentType: '',
    DocumentFormat: '',
    TargetType: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Content":"","Requires":"","Attachments":"","Name":"","DisplayName":"","VersionName":"","DocumentType":"","DocumentFormat":"","TargetType":"","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=AmazonSSM.CreateDocument',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Content": "",\n  "Requires": "",\n  "Attachments": "",\n  "Name": "",\n  "DisplayName": "",\n  "VersionName": "",\n  "DocumentType": "",\n  "DocumentFormat": "",\n  "TargetType": "",\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  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument")
  .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({
  Content: '',
  Requires: '',
  Attachments: '',
  Name: '',
  DisplayName: '',
  VersionName: '',
  DocumentType: '',
  DocumentFormat: '',
  TargetType: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Content: '',
    Requires: '',
    Attachments: '',
    Name: '',
    DisplayName: '',
    VersionName: '',
    DocumentType: '',
    DocumentFormat: '',
    TargetType: '',
    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=AmazonSSM.CreateDocument');

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

req.type('json');
req.send({
  Content: '',
  Requires: '',
  Attachments: '',
  Name: '',
  DisplayName: '',
  VersionName: '',
  DocumentType: '',
  DocumentFormat: '',
  TargetType: '',
  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=AmazonSSM.CreateDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Content: '',
    Requires: '',
    Attachments: '',
    Name: '',
    DisplayName: '',
    VersionName: '',
    DocumentType: '',
    DocumentFormat: '',
    TargetType: '',
    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=AmazonSSM.CreateDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Content":"","Requires":"","Attachments":"","Name":"","DisplayName":"","VersionName":"","DocumentType":"","DocumentFormat":"","TargetType":"","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 = @{ @"Content": @"",
                              @"Requires": @"",
                              @"Attachments": @"",
                              @"Name": @"",
                              @"DisplayName": @"",
                              @"VersionName": @"",
                              @"DocumentType": @"",
                              @"DocumentFormat": @"",
                              @"TargetType": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument"]
                                                       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=AmazonSSM.CreateDocument" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument",
  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([
    'Content' => '',
    'Requires' => '',
    'Attachments' => '',
    'Name' => '',
    'DisplayName' => '',
    'VersionName' => '',
    'DocumentType' => '',
    'DocumentFormat' => '',
    'TargetType' => '',
    '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=AmazonSSM.CreateDocument', [
  'body' => '{
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Content' => '',
  'Requires' => '',
  'Attachments' => '',
  'Name' => '',
  'DisplayName' => '',
  'VersionName' => '',
  'DocumentType' => '',
  'DocumentFormat' => '',
  'TargetType' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Content' => '',
  'Requires' => '',
  'Attachments' => '',
  'Name' => '',
  'DisplayName' => '',
  'VersionName' => '',
  'DocumentType' => '',
  'DocumentFormat' => '',
  'TargetType' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument');
$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=AmazonSSM.CreateDocument' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument"

payload = {
    "Content": "",
    "Requires": "",
    "Attachments": "",
    "Name": "",
    "DisplayName": "",
    "VersionName": "",
    "DocumentType": "",
    "DocumentFormat": "",
    "TargetType": "",
    "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=AmazonSSM.CreateDocument"

payload <- "{\n  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument")

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  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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  \"Content\": \"\",\n  \"Requires\": \"\",\n  \"Attachments\": \"\",\n  \"Name\": \"\",\n  \"DisplayName\": \"\",\n  \"VersionName\": \"\",\n  \"DocumentType\": \"\",\n  \"DocumentFormat\": \"\",\n  \"TargetType\": \"\",\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=AmazonSSM.CreateDocument";

    let payload = json!({
        "Content": "",
        "Requires": "",
        "Attachments": "",
        "Name": "",
        "DisplayName": "",
        "VersionName": "",
        "DocumentType": "",
        "DocumentFormat": "",
        "TargetType": "",
        "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 '{
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Content": "",\n  "Requires": "",\n  "Attachments": "",\n  "Name": "",\n  "DisplayName": "",\n  "VersionName": "",\n  "DocumentType": "",\n  "DocumentFormat": "",\n  "TargetType": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateDocument'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Content": "",
  "Requires": "",
  "Attachments": "",
  "Name": "",
  "DisplayName": "",
  "VersionName": "",
  "DocumentType": "",
  "DocumentFormat": "",
  "TargetType": "",
  "Tags": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:Name ""
                                                                                                          :Description ""
                                                                                                          :StartDate ""
                                                                                                          :EndDate ""
                                                                                                          :Schedule ""
                                                                                                          :ScheduleTimezone ""
                                                                                                          :ScheduleOffset ""
                                                                                                          :Duration ""
                                                                                                          :Cutoff ""
                                                                                                          :AllowUnassociatedTargets ""
                                                                                                          :ClientToken ""
                                                                                                          :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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: 244

{
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow")
  .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=AmazonSSM.CreateMaintenanceWindow")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  StartDate: '',
  EndDate: '',
  Schedule: '',
  ScheduleTimezone: '',
  ScheduleOffset: '',
  Duration: '',
  Cutoff: '',
  AllowUnassociatedTargets: '',
  ClientToken: '',
  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=AmazonSSM.CreateMaintenanceWindow');
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=AmazonSSM.CreateMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    StartDate: '',
    EndDate: '',
    Schedule: '',
    ScheduleTimezone: '',
    ScheduleOffset: '',
    Duration: '',
    Cutoff: '',
    AllowUnassociatedTargets: '',
    ClientToken: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","StartDate":"","EndDate":"","Schedule":"","ScheduleTimezone":"","ScheduleOffset":"","Duration":"","Cutoff":"","AllowUnassociatedTargets":"","ClientToken":"","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=AmazonSSM.CreateMaintenanceWindow',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "StartDate": "",\n  "EndDate": "",\n  "Schedule": "",\n  "ScheduleTimezone": "",\n  "ScheduleOffset": "",\n  "Duration": "",\n  "Cutoff": "",\n  "AllowUnassociatedTargets": "",\n  "ClientToken": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  Name: '',
  Description: '',
  StartDate: '',
  EndDate: '',
  Schedule: '',
  ScheduleTimezone: '',
  ScheduleOffset: '',
  Duration: '',
  Cutoff: '',
  AllowUnassociatedTargets: '',
  ClientToken: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    StartDate: '',
    EndDate: '',
    Schedule: '',
    ScheduleTimezone: '',
    ScheduleOffset: '',
    Duration: '',
    Cutoff: '',
    AllowUnassociatedTargets: '',
    ClientToken: '',
    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=AmazonSSM.CreateMaintenanceWindow');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  StartDate: '',
  EndDate: '',
  Schedule: '',
  ScheduleTimezone: '',
  ScheduleOffset: '',
  Duration: '',
  Cutoff: '',
  AllowUnassociatedTargets: '',
  ClientToken: '',
  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=AmazonSSM.CreateMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    StartDate: '',
    EndDate: '',
    Schedule: '',
    ScheduleTimezone: '',
    ScheduleOffset: '',
    Duration: '',
    Cutoff: '',
    AllowUnassociatedTargets: '',
    ClientToken: '',
    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=AmazonSSM.CreateMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Description":"","StartDate":"","EndDate":"","Schedule":"","ScheduleTimezone":"","ScheduleOffset":"","Duration":"","Cutoff":"","AllowUnassociatedTargets":"","ClientToken":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Description": @"",
                              @"StartDate": @"",
                              @"EndDate": @"",
                              @"Schedule": @"",
                              @"ScheduleTimezone": @"",
                              @"ScheduleOffset": @"",
                              @"Duration": @"",
                              @"Cutoff": @"",
                              @"AllowUnassociatedTargets": @"",
                              @"ClientToken": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow"]
                                                       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=AmazonSSM.CreateMaintenanceWindow" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'StartDate' => '',
    'EndDate' => '',
    'Schedule' => '',
    'ScheduleTimezone' => '',
    'ScheduleOffset' => '',
    'Duration' => '',
    'Cutoff' => '',
    'AllowUnassociatedTargets' => '',
    'ClientToken' => '',
    '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=AmazonSSM.CreateMaintenanceWindow', [
  'body' => '{
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'StartDate' => '',
  'EndDate' => '',
  'Schedule' => '',
  'ScheduleTimezone' => '',
  'ScheduleOffset' => '',
  'Duration' => '',
  'Cutoff' => '',
  'AllowUnassociatedTargets' => '',
  'ClientToken' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'StartDate' => '',
  'EndDate' => '',
  'Schedule' => '',
  'ScheduleTimezone' => '',
  'ScheduleOffset' => '',
  'Duration' => '',
  'Cutoff' => '',
  'AllowUnassociatedTargets' => '',
  'ClientToken' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow');
$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=AmazonSSM.CreateMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow"

payload = {
    "Name": "",
    "Description": "",
    "StartDate": "",
    "EndDate": "",
    "Schedule": "",
    "ScheduleTimezone": "",
    "ScheduleOffset": "",
    "Duration": "",
    "Cutoff": "",
    "AllowUnassociatedTargets": "",
    "ClientToken": "",
    "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=AmazonSSM.CreateMaintenanceWindow"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"StartDate\": \"\",\n  \"EndDate\": \"\",\n  \"Schedule\": \"\",\n  \"ScheduleTimezone\": \"\",\n  \"ScheduleOffset\": \"\",\n  \"Duration\": \"\",\n  \"Cutoff\": \"\",\n  \"AllowUnassociatedTargets\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreateMaintenanceWindow";

    let payload = json!({
        "Name": "",
        "Description": "",
        "StartDate": "",
        "EndDate": "",
        "Schedule": "",
        "ScheduleTimezone": "",
        "ScheduleOffset": "",
        "Duration": "",
        "Cutoff": "",
        "AllowUnassociatedTargets": "",
        "ClientToken": "",
        "Tags": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "StartDate": "",\n  "EndDate": "",\n  "Schedule": "",\n  "ScheduleTimezone": "",\n  "ScheduleOffset": "",\n  "Duration": "",\n  "Cutoff": "",\n  "AllowUnassociatedTargets": "",\n  "ClientToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateMaintenanceWindow'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Description": "",
  "StartDate": "",
  "EndDate": "",
  "Schedule": "",
  "ScheduleTimezone": "",
  "ScheduleOffset": "",
  "Duration": "",
  "Cutoff": "",
  "AllowUnassociatedTargets": "",
  "ClientToken": "",
  "Tags": ""
] as [String : Any]

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

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

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  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem" {:headers {:x-amz-target ""}
                                                                                  :content-type :json
                                                                                  :form-params {:Description ""
                                                                                                :OpsItemType ""
                                                                                                :OperationalData ""
                                                                                                :Notifications ""
                                                                                                :Priority ""
                                                                                                :RelatedOpsItems ""
                                                                                                :Source ""
                                                                                                :Title ""
                                                                                                :Tags ""
                                                                                                :Category ""
                                                                                                :Severity ""
                                                                                                :ActualStartTime ""
                                                                                                :ActualEndTime ""
                                                                                                :PlannedStartTime ""
                                                                                                :PlannedEndTime ""
                                                                                                :AccountId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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=AmazonSSM.CreateOpsItem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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=AmazonSSM.CreateOpsItem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem")
  .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=AmazonSSM.CreateOpsItem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  OpsItemType: '',
  OperationalData: '',
  Notifications: '',
  Priority: '',
  RelatedOpsItems: '',
  Source: '',
  Title: '',
  Tags: '',
  Category: '',
  Severity: '',
  ActualStartTime: '',
  ActualEndTime: '',
  PlannedStartTime: '',
  PlannedEndTime: '',
  AccountId: ''
});

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=AmazonSSM.CreateOpsItem');
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=AmazonSSM.CreateOpsItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Description: '',
    OpsItemType: '',
    OperationalData: '',
    Notifications: '',
    Priority: '',
    RelatedOpsItems: '',
    Source: '',
    Title: '',
    Tags: '',
    Category: '',
    Severity: '',
    ActualStartTime: '',
    ActualEndTime: '',
    PlannedStartTime: '',
    PlannedEndTime: '',
    AccountId: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Description":"","OpsItemType":"","OperationalData":"","Notifications":"","Priority":"","RelatedOpsItems":"","Source":"","Title":"","Tags":"","Category":"","Severity":"","ActualStartTime":"","ActualEndTime":"","PlannedStartTime":"","PlannedEndTime":"","AccountId":""}'
};

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=AmazonSSM.CreateOpsItem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "OpsItemType": "",\n  "OperationalData": "",\n  "Notifications": "",\n  "Priority": "",\n  "RelatedOpsItems": "",\n  "Source": "",\n  "Title": "",\n  "Tags": "",\n  "Category": "",\n  "Severity": "",\n  "ActualStartTime": "",\n  "ActualEndTime": "",\n  "PlannedStartTime": "",\n  "PlannedEndTime": "",\n  "AccountId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem")
  .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({
  Description: '',
  OpsItemType: '',
  OperationalData: '',
  Notifications: '',
  Priority: '',
  RelatedOpsItems: '',
  Source: '',
  Title: '',
  Tags: '',
  Category: '',
  Severity: '',
  ActualStartTime: '',
  ActualEndTime: '',
  PlannedStartTime: '',
  PlannedEndTime: '',
  AccountId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Description: '',
    OpsItemType: '',
    OperationalData: '',
    Notifications: '',
    Priority: '',
    RelatedOpsItems: '',
    Source: '',
    Title: '',
    Tags: '',
    Category: '',
    Severity: '',
    ActualStartTime: '',
    ActualEndTime: '',
    PlannedStartTime: '',
    PlannedEndTime: '',
    AccountId: ''
  },
  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=AmazonSSM.CreateOpsItem');

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

req.type('json');
req.send({
  Description: '',
  OpsItemType: '',
  OperationalData: '',
  Notifications: '',
  Priority: '',
  RelatedOpsItems: '',
  Source: '',
  Title: '',
  Tags: '',
  Category: '',
  Severity: '',
  ActualStartTime: '',
  ActualEndTime: '',
  PlannedStartTime: '',
  PlannedEndTime: '',
  AccountId: ''
});

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=AmazonSSM.CreateOpsItem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Description: '',
    OpsItemType: '',
    OperationalData: '',
    Notifications: '',
    Priority: '',
    RelatedOpsItems: '',
    Source: '',
    Title: '',
    Tags: '',
    Category: '',
    Severity: '',
    ActualStartTime: '',
    ActualEndTime: '',
    PlannedStartTime: '',
    PlannedEndTime: '',
    AccountId: ''
  }
};

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=AmazonSSM.CreateOpsItem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Description":"","OpsItemType":"","OperationalData":"","Notifications":"","Priority":"","RelatedOpsItems":"","Source":"","Title":"","Tags":"","Category":"","Severity":"","ActualStartTime":"","ActualEndTime":"","PlannedStartTime":"","PlannedEndTime":"","AccountId":""}'
};

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 = @{ @"Description": @"",
                              @"OpsItemType": @"",
                              @"OperationalData": @"",
                              @"Notifications": @"",
                              @"Priority": @"",
                              @"RelatedOpsItems": @"",
                              @"Source": @"",
                              @"Title": @"",
                              @"Tags": @"",
                              @"Category": @"",
                              @"Severity": @"",
                              @"ActualStartTime": @"",
                              @"ActualEndTime": @"",
                              @"PlannedStartTime": @"",
                              @"PlannedEndTime": @"",
                              @"AccountId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem"]
                                                       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=AmazonSSM.CreateOpsItem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem",
  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([
    'Description' => '',
    'OpsItemType' => '',
    'OperationalData' => '',
    'Notifications' => '',
    'Priority' => '',
    'RelatedOpsItems' => '',
    'Source' => '',
    'Title' => '',
    'Tags' => '',
    'Category' => '',
    'Severity' => '',
    'ActualStartTime' => '',
    'ActualEndTime' => '',
    'PlannedStartTime' => '',
    'PlannedEndTime' => '',
    'AccountId' => ''
  ]),
  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=AmazonSSM.CreateOpsItem', [
  'body' => '{
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'OpsItemType' => '',
  'OperationalData' => '',
  'Notifications' => '',
  'Priority' => '',
  'RelatedOpsItems' => '',
  'Source' => '',
  'Title' => '',
  'Tags' => '',
  'Category' => '',
  'Severity' => '',
  'ActualStartTime' => '',
  'ActualEndTime' => '',
  'PlannedStartTime' => '',
  'PlannedEndTime' => '',
  'AccountId' => ''
]));

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

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

append(json_encode([
  'Description' => '',
  'OpsItemType' => '',
  'OperationalData' => '',
  'Notifications' => '',
  'Priority' => '',
  'RelatedOpsItems' => '',
  'Source' => '',
  'Title' => '',
  'Tags' => '',
  'Category' => '',
  'Severity' => '',
  'ActualStartTime' => '',
  'ActualEndTime' => '',
  'PlannedStartTime' => '',
  'PlannedEndTime' => '',
  'AccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem');
$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=AmazonSSM.CreateOpsItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
}'

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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=AmazonSSM.CreateOpsItem"

payload = {
    "Description": "",
    "OpsItemType": "",
    "OperationalData": "",
    "Notifications": "",
    "Priority": "",
    "RelatedOpsItems": "",
    "Source": "",
    "Title": "",
    "Tags": "",
    "Category": "",
    "Severity": "",
    "ActualStartTime": "",
    "ActualEndTime": "",
    "PlannedStartTime": "",
    "PlannedEndTime": "",
    "AccountId": ""
}
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=AmazonSSM.CreateOpsItem"

payload <- "{\n  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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=AmazonSSM.CreateOpsItem")

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  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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  \"Description\": \"\",\n  \"OpsItemType\": \"\",\n  \"OperationalData\": \"\",\n  \"Notifications\": \"\",\n  \"Priority\": \"\",\n  \"RelatedOpsItems\": \"\",\n  \"Source\": \"\",\n  \"Title\": \"\",\n  \"Tags\": \"\",\n  \"Category\": \"\",\n  \"Severity\": \"\",\n  \"ActualStartTime\": \"\",\n  \"ActualEndTime\": \"\",\n  \"PlannedStartTime\": \"\",\n  \"PlannedEndTime\": \"\",\n  \"AccountId\": \"\"\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=AmazonSSM.CreateOpsItem";

    let payload = json!({
        "Description": "",
        "OpsItemType": "",
        "OperationalData": "",
        "Notifications": "",
        "Priority": "",
        "RelatedOpsItems": "",
        "Source": "",
        "Title": "",
        "Tags": "",
        "Category": "",
        "Severity": "",
        "ActualStartTime": "",
        "ActualEndTime": "",
        "PlannedStartTime": "",
        "PlannedEndTime": "",
        "AccountId": ""
    });

    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 '{
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "OpsItemType": "",\n  "OperationalData": "",\n  "Notifications": "",\n  "Priority": "",\n  "RelatedOpsItems": "",\n  "Source": "",\n  "Title": "",\n  "Tags": "",\n  "Category": "",\n  "Severity": "",\n  "ActualStartTime": "",\n  "ActualEndTime": "",\n  "PlannedStartTime": "",\n  "PlannedEndTime": "",\n  "AccountId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsItem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Description": "",
  "OpsItemType": "",
  "OperationalData": "",
  "Notifications": "",
  "Priority": "",
  "RelatedOpsItems": "",
  "Source": "",
  "Title": "",
  "Tags": "",
  "Category": "",
  "Severity": "",
  "ActualStartTime": "",
  "ActualEndTime": "",
  "PlannedStartTime": "",
  "PlannedEndTime": "",
  "AccountId": ""
] as [String : Any]

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

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

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  \"ResourceId\": \"\",\n  \"Metadata\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsMetadata" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:ResourceId ""
                                                                                                    :Metadata ""
                                                                                                    :Tags ""}})

require "http/client"

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

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

{
  "ResourceId": "",
  "Metadata": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ResourceId: '',
  Metadata: '',
  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=AmazonSSM.CreateOpsMetadata');
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=AmazonSSM.CreateOpsMetadata',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', Metadata: '', Tags: ''}
};

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

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

const request = require('request');

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

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

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

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceId' => '',
  'Metadata' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceId\": \"\",\n  \"Metadata\": \"\",\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=AmazonSSM.CreateOpsMetadata"

payload = {
    "ResourceId": "",
    "Metadata": "",
    "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=AmazonSSM.CreateOpsMetadata"

payload <- "{\n  \"ResourceId\": \"\",\n  \"Metadata\": \"\",\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=AmazonSSM.CreateOpsMetadata")

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  \"ResourceId\": \"\",\n  \"Metadata\": \"\",\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  \"ResourceId\": \"\",\n  \"Metadata\": \"\",\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=AmazonSSM.CreateOpsMetadata";

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

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceId": "",\n  "Metadata": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateOpsMetadata'

import Foundation

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

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

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

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  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:OperatingSystem ""
                                                                                                      :Name ""
                                                                                                      :GlobalFilters ""
                                                                                                      :ApprovalRules ""
                                                                                                      :ApprovedPatches ""
                                                                                                      :ApprovedPatchesComplianceLevel ""
                                                                                                      :ApprovedPatchesEnableNonSecurity ""
                                                                                                      :RejectedPatches ""
                                                                                                      :RejectedPatchesAction ""
                                                                                                      :Description ""
                                                                                                      :Sources ""
                                                                                                      :ClientToken ""
                                                                                                      :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline"

	payload := strings.NewReader("{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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: 323

{
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline")
  .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=AmazonSSM.CreatePatchBaseline")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  OperatingSystem: '',
  Name: '',
  GlobalFilters: '',
  ApprovalRules: '',
  ApprovedPatches: '',
  ApprovedPatchesComplianceLevel: '',
  ApprovedPatchesEnableNonSecurity: '',
  RejectedPatches: '',
  RejectedPatchesAction: '',
  Description: '',
  Sources: '',
  ClientToken: '',
  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=AmazonSSM.CreatePatchBaseline');
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=AmazonSSM.CreatePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    OperatingSystem: '',
    Name: '',
    GlobalFilters: '',
    ApprovalRules: '',
    ApprovedPatches: '',
    ApprovedPatchesComplianceLevel: '',
    ApprovedPatchesEnableNonSecurity: '',
    RejectedPatches: '',
    RejectedPatchesAction: '',
    Description: '',
    Sources: '',
    ClientToken: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"OperatingSystem":"","Name":"","GlobalFilters":"","ApprovalRules":"","ApprovedPatches":"","ApprovedPatchesComplianceLevel":"","ApprovedPatchesEnableNonSecurity":"","RejectedPatches":"","RejectedPatchesAction":"","Description":"","Sources":"","ClientToken":"","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=AmazonSSM.CreatePatchBaseline',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "OperatingSystem": "",\n  "Name": "",\n  "GlobalFilters": "",\n  "ApprovalRules": "",\n  "ApprovedPatches": "",\n  "ApprovedPatchesComplianceLevel": "",\n  "ApprovedPatchesEnableNonSecurity": "",\n  "RejectedPatches": "",\n  "RejectedPatchesAction": "",\n  "Description": "",\n  "Sources": "",\n  "ClientToken": "",\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  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline")
  .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({
  OperatingSystem: '',
  Name: '',
  GlobalFilters: '',
  ApprovalRules: '',
  ApprovedPatches: '',
  ApprovedPatchesComplianceLevel: '',
  ApprovedPatchesEnableNonSecurity: '',
  RejectedPatches: '',
  RejectedPatchesAction: '',
  Description: '',
  Sources: '',
  ClientToken: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    OperatingSystem: '',
    Name: '',
    GlobalFilters: '',
    ApprovalRules: '',
    ApprovedPatches: '',
    ApprovedPatchesComplianceLevel: '',
    ApprovedPatchesEnableNonSecurity: '',
    RejectedPatches: '',
    RejectedPatchesAction: '',
    Description: '',
    Sources: '',
    ClientToken: '',
    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=AmazonSSM.CreatePatchBaseline');

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

req.type('json');
req.send({
  OperatingSystem: '',
  Name: '',
  GlobalFilters: '',
  ApprovalRules: '',
  ApprovedPatches: '',
  ApprovedPatchesComplianceLevel: '',
  ApprovedPatchesEnableNonSecurity: '',
  RejectedPatches: '',
  RejectedPatchesAction: '',
  Description: '',
  Sources: '',
  ClientToken: '',
  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=AmazonSSM.CreatePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    OperatingSystem: '',
    Name: '',
    GlobalFilters: '',
    ApprovalRules: '',
    ApprovedPatches: '',
    ApprovedPatchesComplianceLevel: '',
    ApprovedPatchesEnableNonSecurity: '',
    RejectedPatches: '',
    RejectedPatchesAction: '',
    Description: '',
    Sources: '',
    ClientToken: '',
    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=AmazonSSM.CreatePatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"OperatingSystem":"","Name":"","GlobalFilters":"","ApprovalRules":"","ApprovedPatches":"","ApprovedPatchesComplianceLevel":"","ApprovedPatchesEnableNonSecurity":"","RejectedPatches":"","RejectedPatchesAction":"","Description":"","Sources":"","ClientToken":"","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 = @{ @"OperatingSystem": @"",
                              @"Name": @"",
                              @"GlobalFilters": @"",
                              @"ApprovalRules": @"",
                              @"ApprovedPatches": @"",
                              @"ApprovedPatchesComplianceLevel": @"",
                              @"ApprovedPatchesEnableNonSecurity": @"",
                              @"RejectedPatches": @"",
                              @"RejectedPatchesAction": @"",
                              @"Description": @"",
                              @"Sources": @"",
                              @"ClientToken": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline"]
                                                       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=AmazonSSM.CreatePatchBaseline" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline",
  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([
    'OperatingSystem' => '',
    'Name' => '',
    'GlobalFilters' => '',
    'ApprovalRules' => '',
    'ApprovedPatches' => '',
    'ApprovedPatchesComplianceLevel' => '',
    'ApprovedPatchesEnableNonSecurity' => '',
    'RejectedPatches' => '',
    'RejectedPatchesAction' => '',
    'Description' => '',
    'Sources' => '',
    'ClientToken' => '',
    '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=AmazonSSM.CreatePatchBaseline', [
  'body' => '{
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'OperatingSystem' => '',
  'Name' => '',
  'GlobalFilters' => '',
  'ApprovalRules' => '',
  'ApprovedPatches' => '',
  'ApprovedPatchesComplianceLevel' => '',
  'ApprovedPatchesEnableNonSecurity' => '',
  'RejectedPatches' => '',
  'RejectedPatchesAction' => '',
  'Description' => '',
  'Sources' => '',
  'ClientToken' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'OperatingSystem' => '',
  'Name' => '',
  'GlobalFilters' => '',
  'ApprovalRules' => '',
  'ApprovedPatches' => '',
  'ApprovedPatchesComplianceLevel' => '',
  'ApprovedPatchesEnableNonSecurity' => '',
  'RejectedPatches' => '',
  'RejectedPatchesAction' => '',
  'Description' => '',
  'Sources' => '',
  'ClientToken' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline');
$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=AmazonSSM.CreatePatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline"

payload = {
    "OperatingSystem": "",
    "Name": "",
    "GlobalFilters": "",
    "ApprovalRules": "",
    "ApprovedPatches": "",
    "ApprovedPatchesComplianceLevel": "",
    "ApprovedPatchesEnableNonSecurity": "",
    "RejectedPatches": "",
    "RejectedPatchesAction": "",
    "Description": "",
    "Sources": "",
    "ClientToken": "",
    "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=AmazonSSM.CreatePatchBaseline"

payload <- "{\n  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline")

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  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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  \"OperatingSystem\": \"\",\n  \"Name\": \"\",\n  \"GlobalFilters\": \"\",\n  \"ApprovalRules\": \"\",\n  \"ApprovedPatches\": \"\",\n  \"ApprovedPatchesComplianceLevel\": \"\",\n  \"ApprovedPatchesEnableNonSecurity\": \"\",\n  \"RejectedPatches\": \"\",\n  \"RejectedPatchesAction\": \"\",\n  \"Description\": \"\",\n  \"Sources\": \"\",\n  \"ClientToken\": \"\",\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=AmazonSSM.CreatePatchBaseline";

    let payload = json!({
        "OperatingSystem": "",
        "Name": "",
        "GlobalFilters": "",
        "ApprovalRules": "",
        "ApprovedPatches": "",
        "ApprovedPatchesComplianceLevel": "",
        "ApprovedPatchesEnableNonSecurity": "",
        "RejectedPatches": "",
        "RejectedPatchesAction": "",
        "Description": "",
        "Sources": "",
        "ClientToken": "",
        "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 '{
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "OperatingSystem": "",\n  "Name": "",\n  "GlobalFilters": "",\n  "ApprovalRules": "",\n  "ApprovedPatches": "",\n  "ApprovedPatchesComplianceLevel": "",\n  "ApprovedPatchesEnableNonSecurity": "",\n  "RejectedPatches": "",\n  "RejectedPatchesAction": "",\n  "Description": "",\n  "Sources": "",\n  "ClientToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreatePatchBaseline'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "OperatingSystem": "",
  "Name": "",
  "GlobalFilters": "",
  "ApprovalRules": "",
  "ApprovedPatches": "",
  "ApprovedPatchesComplianceLevel": "",
  "ApprovedPatchesEnableNonSecurity": "",
  "RejectedPatches": "",
  "RejectedPatchesAction": "",
  "Description": "",
  "Sources": "",
  "ClientToken": "",
  "Tags": ""
] as [String : Any]

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

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

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  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateResourceDataSync" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:SyncName ""
                                                                                                         :S3Destination ""
                                                                                                         :SyncType ""
                                                                                                         :SyncSource ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateResourceDataSync"

	payload := strings.NewReader("{\n  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\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

{
  "SyncName": "",
  "S3Destination": "",
  "SyncType": "",
  "SyncSource": ""
}

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

client.close();

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

const data = JSON.stringify({
  SyncName: '',
  S3Destination: '',
  SyncType: '',
  SyncSource: ''
});

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=AmazonSSM.CreateResourceDataSync');
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=AmazonSSM.CreateResourceDataSync',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SyncName: '', S3Destination: '', SyncType: '', SyncSource: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateResourceDataSync';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SyncName":"","S3Destination":"","SyncType":"","SyncSource":""}'
};

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=AmazonSSM.CreateResourceDataSync',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SyncName": "",\n  "S3Destination": "",\n  "SyncType": "",\n  "SyncSource": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  SyncName: '',
  S3Destination: '',
  SyncType: '',
  SyncSource: ''
});

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=AmazonSSM.CreateResourceDataSync',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SyncName: '', S3Destination: '', SyncType: '', SyncSource: ''}
};

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=AmazonSSM.CreateResourceDataSync';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SyncName":"","S3Destination":"","SyncType":"","SyncSource":""}'
};

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 = @{ @"SyncName": @"",
                              @"S3Destination": @"",
                              @"SyncType": @"",
                              @"SyncSource": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SyncName' => '',
  'S3Destination' => '',
  'SyncType' => '',
  'SyncSource' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\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=AmazonSSM.CreateResourceDataSync"

payload = {
    "SyncName": "",
    "S3Destination": "",
    "SyncType": "",
    "SyncSource": ""
}
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=AmazonSSM.CreateResourceDataSync"

payload <- "{\n  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\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=AmazonSSM.CreateResourceDataSync")

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  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\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  \"SyncName\": \"\",\n  \"S3Destination\": \"\",\n  \"SyncType\": \"\",\n  \"SyncSource\": \"\"\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=AmazonSSM.CreateResourceDataSync";

    let payload = json!({
        "SyncName": "",
        "S3Destination": "",
        "SyncType": "",
        "SyncSource": ""
    });

    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 '{
  "SyncName": "",
  "S3Destination": "",
  "SyncType": "",
  "SyncSource": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateResourceDataSync' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SyncName": "",\n  "S3Destination": "",\n  "SyncType": "",\n  "SyncSource": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.CreateResourceDataSync'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteActivation"

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

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

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

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

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

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

}

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

{
  "ActivationId": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ActivationId\": \"\"\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=AmazonSSM.DeleteActivation"

payload = { "ActivationId": "" }
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=AmazonSSM.DeleteActivation"

payload <- "{\n  \"ActivationId\": \"\"\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=AmazonSSM.DeleteActivation")

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  \"ActivationId\": \"\"\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  \"ActivationId\": \"\"\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=AmazonSSM.DeleteActivation";

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

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

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

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteAssociation" {:headers {:x-amz-target ""}
                                                                                      :content-type :json
                                                                                      :form-params {:Name ""
                                                                                                    :InstanceId ""
                                                                                                    :AssociationId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteAssociation"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "InstanceId": "",
  "AssociationId": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({
  Name: '',
  InstanceId: '',
  AssociationId: ''
});

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=AmazonSSM.DeleteAssociation');
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=AmazonSSM.DeleteAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', InstanceId: '', AssociationId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","InstanceId":"","AssociationId":""}'
};

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Name: '', InstanceId: '', AssociationId: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Name: '',
  InstanceId: '',
  AssociationId: ''
});

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=AmazonSSM.DeleteAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', InstanceId: '', AssociationId: ''}
};

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=AmazonSSM.DeleteAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","InstanceId":"","AssociationId":""}'
};

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'InstanceId' => '',
  'AssociationId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\"\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=AmazonSSM.DeleteAssociation"

payload = {
    "Name": "",
    "InstanceId": "",
    "AssociationId": ""
}
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=AmazonSSM.DeleteAssociation"

payload <- "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\"\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=AmazonSSM.DeleteAssociation")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\"\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=AmazonSSM.DeleteAssociation";

    let payload = json!({
        "Name": "",
        "InstanceId": "",
        "AssociationId": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "InstanceId": "",
  "AssociationId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteAssociation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "InstanceId": "",\n  "AssociationId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteAssociation'

import Foundation

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

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument" {:headers {:x-amz-target ""}
                                                                                   :content-type :json
                                                                                   :form-params {:Name ""
                                                                                                 :DocumentVersion ""
                                                                                                 :VersionName ""
                                                                                                 :Force ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": "",
  "Force": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({
  Name: '',
  DocumentVersion: '',
  VersionName: '',
  Force: ''
});

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=AmazonSSM.DeleteDocument');
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=AmazonSSM.DeleteDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', DocumentVersion: '', VersionName: '', Force: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","VersionName":"","Force":""}'
};

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=AmazonSSM.DeleteDocument',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DocumentVersion": "",\n  "VersionName": "",\n  "Force": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Name: '', DocumentVersion: '', VersionName: '', Force: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Name: '',
  DocumentVersion: '',
  VersionName: '',
  Force: ''
});

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=AmazonSSM.DeleteDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', DocumentVersion: '', VersionName: '', Force: ''}
};

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=AmazonSSM.DeleteDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","VersionName":"","Force":""}'
};

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DocumentVersion' => '',
  'VersionName' => '',
  'Force' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\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=AmazonSSM.DeleteDocument"

payload = {
    "Name": "",
    "DocumentVersion": "",
    "VersionName": "",
    "Force": ""
}
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=AmazonSSM.DeleteDocument"

payload <- "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\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=AmazonSSM.DeleteDocument")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\",\n  \"Force\": \"\"\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=AmazonSSM.DeleteDocument";

    let payload = json!({
        "Name": "",
        "DocumentVersion": "",
        "VersionName": "",
        "Force": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": "",
  "Force": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DocumentVersion": "",\n  "VersionName": "",\n  "Force": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteDocument'

import Foundation

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

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

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

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  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory" {:headers {:x-amz-target ""}
                                                                                    :content-type :json
                                                                                    :form-params {:TypeName ""
                                                                                                  :SchemaDeleteOption ""
                                                                                                  :DryRun ""
                                                                                                  :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory"

	payload := strings.NewReader("{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "TypeName": "",
  "SchemaDeleteOption": "",
  "DryRun": "",
  "ClientToken": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({
  TypeName: '',
  SchemaDeleteOption: '',
  DryRun: '',
  ClientToken: ''
});

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

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

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TypeName":"","SchemaDeleteOption":"","DryRun":"","ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TypeName": "",\n  "SchemaDeleteOption": "",\n  "DryRun": "",\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TypeName: '', SchemaDeleteOption: '', DryRun: '', ClientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  TypeName: '',
  SchemaDeleteOption: '',
  DryRun: '',
  ClientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TypeName: '', SchemaDeleteOption: '', DryRun: '', ClientToken: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TypeName":"","SchemaDeleteOption":"","DryRun":"","ClientToken":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory",
  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([
    'TypeName' => '',
    'SchemaDeleteOption' => '',
    'DryRun' => '',
    'ClientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory', [
  'body' => '{
  "TypeName": "",
  "SchemaDeleteOption": "",
  "DryRun": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TypeName' => '',
  'SchemaDeleteOption' => '',
  'DryRun' => '',
  'ClientToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory"

payload <- "{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TypeName\": \"\",\n  \"SchemaDeleteOption\": \"\",\n  \"DryRun\": \"\",\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "TypeName": "",
        "SchemaDeleteOption": "",
        "DryRun": "",
        "ClientToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "TypeName": "",
  "SchemaDeleteOption": "",
  "DryRun": "",
  "ClientToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TypeName": "",\n  "SchemaDeleteOption": "",\n  "DryRun": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteInventory'

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteMaintenanceWindow"

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

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

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

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

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

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

}

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

{
  "WindowId": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"WindowId\": \"\"\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=AmazonSSM.DeleteMaintenanceWindow"

payload = { "WindowId": "" }
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=AmazonSSM.DeleteMaintenanceWindow"

payload <- "{\n  \"WindowId\": \"\"\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=AmazonSSM.DeleteMaintenanceWindow")

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  \"WindowId\": \"\"\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  \"WindowId\": \"\"\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=AmazonSSM.DeleteMaintenanceWindow";

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

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

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

import Foundation

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteOpsMetadata"

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

{
  "OpsMetadataArn": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"OpsMetadataArn\": \"\"\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=AmazonSSM.DeleteOpsMetadata"

payload = { "OpsMetadataArn": "" }
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=AmazonSSM.DeleteOpsMetadata"

payload <- "{\n  \"OpsMetadataArn\": \"\"\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=AmazonSSM.DeleteOpsMetadata")

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  \"OpsMetadataArn\": \"\"\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  \"OpsMetadataArn\": \"\"\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=AmazonSSM.DeleteOpsMetadata";

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

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

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

import Foundation

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

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameter"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameter"

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

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

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

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

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

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

}

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

{
  "Name": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameter"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameter"

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

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Names\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters"

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

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

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

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

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

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

}

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

{
  "Names": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

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

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'Names' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters');
$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=AmazonSSM.DeleteParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Names": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Names\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters"

payload = { "Names": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters"

payload <- "{\n  \"Names\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Names\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Names\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters";

    let payload = json!({"Names": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Names": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Names": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Names": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteParameters")! 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=AmazonSSM.DeletePatchBaseline");

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  \"BaselineId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:BaselineId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"BaselineId\": \"\"\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=AmazonSSM.DeletePatchBaseline"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"BaselineId\": \"\"\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=AmazonSSM.DeletePatchBaseline");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BaselineId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline"

	payload := strings.NewReader("{\n  \"BaselineId\": \"\"\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: 22

{
  "BaselineId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BaselineId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BaselineId\": \"\"\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  \"BaselineId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline")
  .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=AmazonSSM.DeletePatchBaseline")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"BaselineId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BaselineId: ''
});

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=AmazonSSM.DeletePatchBaseline');
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=AmazonSSM.DeletePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":""}'
};

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=AmazonSSM.DeletePatchBaseline',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BaselineId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BaselineId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline")
  .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({BaselineId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {BaselineId: ''},
  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=AmazonSSM.DeletePatchBaseline');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BaselineId: ''
});

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=AmazonSSM.DeletePatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: ''}
};

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=AmazonSSM.DeletePatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":""}'
};

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 = @{ @"BaselineId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline"]
                                                       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=AmazonSSM.DeletePatchBaseline" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"BaselineId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline",
  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([
    'BaselineId' => ''
  ]),
  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=AmazonSSM.DeletePatchBaseline', [
  'body' => '{
  "BaselineId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BaselineId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BaselineId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline');
$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=AmazonSSM.DeletePatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BaselineId\": \"\"\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=AmazonSSM.DeletePatchBaseline"

payload = { "BaselineId": "" }
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=AmazonSSM.DeletePatchBaseline"

payload <- "{\n  \"BaselineId\": \"\"\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=AmazonSSM.DeletePatchBaseline")

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  \"BaselineId\": \"\"\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  \"BaselineId\": \"\"\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=AmazonSSM.DeletePatchBaseline";

    let payload = json!({"BaselineId": ""});

    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 '{
  "BaselineId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "BaselineId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["BaselineId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeletePatchBaseline")! 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=AmazonSSM.DeleteResourceDataSync");

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  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:SyncName ""
                                                                                                         :SyncType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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=AmazonSSM.DeleteResourceDataSync"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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=AmazonSSM.DeleteResourceDataSync");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync"

	payload := strings.NewReader("{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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

{
  "SyncName": "",
  "SyncType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync")
  .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=AmazonSSM.DeleteResourceDataSync")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SyncName: '',
  SyncType: ''
});

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=AmazonSSM.DeleteResourceDataSync');
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=AmazonSSM.DeleteResourceDataSync',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SyncName: '', SyncType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SyncName":"","SyncType":""}'
};

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=AmazonSSM.DeleteResourceDataSync',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SyncName": "",\n  "SyncType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync")
  .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({SyncName: '', SyncType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {SyncName: '', SyncType: ''},
  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=AmazonSSM.DeleteResourceDataSync');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SyncName: '',
  SyncType: ''
});

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=AmazonSSM.DeleteResourceDataSync',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SyncName: '', SyncType: ''}
};

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=AmazonSSM.DeleteResourceDataSync';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SyncName":"","SyncType":""}'
};

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 = @{ @"SyncName": @"",
                              @"SyncType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync"]
                                                       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=AmazonSSM.DeleteResourceDataSync" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync",
  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([
    'SyncName' => '',
    'SyncType' => ''
  ]),
  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=AmazonSSM.DeleteResourceDataSync', [
  'body' => '{
  "SyncName": "",
  "SyncType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SyncName' => '',
  'SyncType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SyncName' => '',
  'SyncType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync');
$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=AmazonSSM.DeleteResourceDataSync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SyncName": "",
  "SyncType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SyncName": "",
  "SyncType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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=AmazonSSM.DeleteResourceDataSync"

payload = {
    "SyncName": "",
    "SyncType": ""
}
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=AmazonSSM.DeleteResourceDataSync"

payload <- "{\n  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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=AmazonSSM.DeleteResourceDataSync")

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  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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  \"SyncName\": \"\",\n  \"SyncType\": \"\"\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=AmazonSSM.DeleteResourceDataSync";

    let payload = json!({
        "SyncName": "",
        "SyncType": ""
    });

    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 '{
  "SyncName": "",
  "SyncType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SyncName": "",\n  "SyncType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SyncName": "",
  "SyncType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourceDataSync")! 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=AmazonSSM.DeleteResourcePolicy");

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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:ResourceArn ""
                                                                                                       :PolicyId ""
                                                                                                       :PolicyHash ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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=AmazonSSM.DeleteResourcePolicy"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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=AmazonSSM.DeleteResourcePolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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: 61

{
  "ResourceArn": "",
  "PolicyId": "",
  "PolicyHash": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy")
  .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=AmazonSSM.DeleteResourcePolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  PolicyId: '',
  PolicyHash: ''
});

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=AmazonSSM.DeleteResourcePolicy');
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=AmazonSSM.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', PolicyId: '', PolicyHash: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","PolicyId":"","PolicyHash":""}'
};

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=AmazonSSM.DeleteResourcePolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "PolicyId": "",\n  "PolicyHash": ""\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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy")
  .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: '', PolicyId: '', PolicyHash: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', PolicyId: '', PolicyHash: ''},
  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=AmazonSSM.DeleteResourcePolicy');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceArn: '',
  PolicyId: '',
  PolicyHash: ''
});

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=AmazonSSM.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', PolicyId: '', PolicyHash: ''}
};

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=AmazonSSM.DeleteResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","PolicyId":"","PolicyHash":""}'
};

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": @"",
                              @"PolicyId": @"",
                              @"PolicyHash": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy"]
                                                       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=AmazonSSM.DeleteResourcePolicy" 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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy",
  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' => '',
    'PolicyId' => '',
    'PolicyHash' => ''
  ]),
  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=AmazonSSM.DeleteResourcePolicy', [
  'body' => '{
  "ResourceArn": "",
  "PolicyId": "",
  "PolicyHash": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceArn' => '',
  'PolicyId' => '',
  'PolicyHash' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceArn' => '',
  'PolicyId' => '',
  'PolicyHash' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy');
$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=AmazonSSM.DeleteResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "PolicyId": "",
  "PolicyHash": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "PolicyId": "",
  "PolicyHash": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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=AmazonSSM.DeleteResourcePolicy"

payload = {
    "ResourceArn": "",
    "PolicyId": "",
    "PolicyHash": ""
}
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=AmazonSSM.DeleteResourcePolicy"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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=AmazonSSM.DeleteResourcePolicy")

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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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  \"PolicyId\": \"\",\n  \"PolicyHash\": \"\"\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=AmazonSSM.DeleteResourcePolicy";

    let payload = json!({
        "ResourceArn": "",
        "PolicyId": "",
        "PolicyHash": ""
    });

    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": "",
  "PolicyId": "",
  "PolicyHash": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy' \
  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  "PolicyId": "",\n  "PolicyHash": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceArn": "",
  "PolicyId": "",
  "PolicyHash": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeleteResourcePolicy")! 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=AmazonSSM.DeregisterManagedInstance");

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  \"InstanceId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:InstanceId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\"\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=AmazonSSM.DeregisterManagedInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceId\": \"\"\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=AmazonSSM.DeregisterManagedInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\"\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: 22

{
  "InstanceId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\"\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  \"InstanceId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance")
  .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=AmazonSSM.DeregisterManagedInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: ''
});

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=AmazonSSM.DeregisterManagedInstance');
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=AmazonSSM.DeregisterManagedInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":""}'
};

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=AmazonSSM.DeregisterManagedInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance")
  .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({InstanceId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceId: ''},
  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=AmazonSSM.DeregisterManagedInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceId: ''
});

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=AmazonSSM.DeregisterManagedInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: ''}
};

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=AmazonSSM.DeregisterManagedInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":""}'
};

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 = @{ @"InstanceId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance"]
                                                       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=AmazonSSM.DeregisterManagedInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance",
  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([
    'InstanceId' => ''
  ]),
  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=AmazonSSM.DeregisterManagedInstance', [
  'body' => '{
  "InstanceId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance');
$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=AmazonSSM.DeregisterManagedInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceId\": \"\"\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=AmazonSSM.DeregisterManagedInstance"

payload = { "InstanceId": "" }
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=AmazonSSM.DeregisterManagedInstance"

payload <- "{\n  \"InstanceId\": \"\"\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=AmazonSSM.DeregisterManagedInstance")

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  \"InstanceId\": \"\"\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  \"InstanceId\": \"\"\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=AmazonSSM.DeregisterManagedInstance";

    let payload = json!({"InstanceId": ""});

    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 '{
  "InstanceId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["InstanceId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterManagedInstance")! 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=AmazonSSM.DeregisterPatchBaselineForPatchGroup");

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  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:BaselineId ""
                                                                                                                       :PatchGroup ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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=AmazonSSM.DeregisterPatchBaselineForPatchGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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=AmazonSSM.DeregisterPatchBaselineForPatchGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup"

	payload := strings.NewReader("{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "BaselineId": "",
  "PatchGroup": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup")
  .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=AmazonSSM.DeregisterPatchBaselineForPatchGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BaselineId: '',
  PatchGroup: ''
});

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=AmazonSSM.DeregisterPatchBaselineForPatchGroup');
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=AmazonSSM.DeregisterPatchBaselineForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: '', PatchGroup: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":"","PatchGroup":""}'
};

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=AmazonSSM.DeregisterPatchBaselineForPatchGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BaselineId": "",\n  "PatchGroup": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup")
  .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({BaselineId: '', PatchGroup: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {BaselineId: '', PatchGroup: ''},
  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=AmazonSSM.DeregisterPatchBaselineForPatchGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BaselineId: '',
  PatchGroup: ''
});

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=AmazonSSM.DeregisterPatchBaselineForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: '', PatchGroup: ''}
};

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=AmazonSSM.DeregisterPatchBaselineForPatchGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":"","PatchGroup":""}'
};

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 = @{ @"BaselineId": @"",
                              @"PatchGroup": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup"]
                                                       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=AmazonSSM.DeregisterPatchBaselineForPatchGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup",
  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([
    'BaselineId' => '',
    'PatchGroup' => ''
  ]),
  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=AmazonSSM.DeregisterPatchBaselineForPatchGroup', [
  'body' => '{
  "BaselineId": "",
  "PatchGroup": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BaselineId' => '',
  'PatchGroup' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BaselineId' => '',
  'PatchGroup' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup');
$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=AmazonSSM.DeregisterPatchBaselineForPatchGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": "",
  "PatchGroup": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": "",
  "PatchGroup": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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=AmazonSSM.DeregisterPatchBaselineForPatchGroup"

payload = {
    "BaselineId": "",
    "PatchGroup": ""
}
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=AmazonSSM.DeregisterPatchBaselineForPatchGroup"

payload <- "{\n  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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=AmazonSSM.DeregisterPatchBaselineForPatchGroup")

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  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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  \"BaselineId\": \"\",\n  \"PatchGroup\": \"\"\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=AmazonSSM.DeregisterPatchBaselineForPatchGroup";

    let payload = json!({
        "BaselineId": "",
        "PatchGroup": ""
    });

    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 '{
  "BaselineId": "",
  "PatchGroup": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "BaselineId": "",\n  "PatchGroup": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "BaselineId": "",
  "PatchGroup": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterPatchBaselineForPatchGroup")! 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=AmazonSSM.DeregisterTargetFromMaintenanceWindow");

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  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:WindowId ""
                                                                                                                        :WindowTargetId ""
                                                                                                                        :Safe ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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=AmazonSSM.DeregisterTargetFromMaintenanceWindow"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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=AmazonSSM.DeregisterTargetFromMaintenanceWindow");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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

{
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow")
  .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=AmazonSSM.DeregisterTargetFromMaintenanceWindow")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  WindowTargetId: '',
  Safe: ''
});

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=AmazonSSM.DeregisterTargetFromMaintenanceWindow');
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=AmazonSSM.DeregisterTargetFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', WindowTargetId: '', Safe: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","WindowTargetId":"","Safe":""}'
};

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=AmazonSSM.DeregisterTargetFromMaintenanceWindow',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "WindowTargetId": "",\n  "Safe": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow")
  .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({WindowId: '', WindowTargetId: '', Safe: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowId: '', WindowTargetId: '', Safe: ''},
  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=AmazonSSM.DeregisterTargetFromMaintenanceWindow');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  WindowTargetId: '',
  Safe: ''
});

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=AmazonSSM.DeregisterTargetFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', WindowTargetId: '', Safe: ''}
};

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=AmazonSSM.DeregisterTargetFromMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","WindowTargetId":"","Safe":""}'
};

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 = @{ @"WindowId": @"",
                              @"WindowTargetId": @"",
                              @"Safe": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow"]
                                                       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=AmazonSSM.DeregisterTargetFromMaintenanceWindow" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow",
  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([
    'WindowId' => '',
    'WindowTargetId' => '',
    'Safe' => ''
  ]),
  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=AmazonSSM.DeregisterTargetFromMaintenanceWindow', [
  'body' => '{
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'WindowTargetId' => '',
  'Safe' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'WindowTargetId' => '',
  'Safe' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow');
$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=AmazonSSM.DeregisterTargetFromMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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=AmazonSSM.DeregisterTargetFromMaintenanceWindow"

payload = {
    "WindowId": "",
    "WindowTargetId": "",
    "Safe": ""
}
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=AmazonSSM.DeregisterTargetFromMaintenanceWindow"

payload <- "{\n  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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=AmazonSSM.DeregisterTargetFromMaintenanceWindow")

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  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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  \"WindowId\": \"\",\n  \"WindowTargetId\": \"\",\n  \"Safe\": \"\"\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=AmazonSSM.DeregisterTargetFromMaintenanceWindow";

    let payload = json!({
        "WindowId": "",
        "WindowTargetId": "",
        "Safe": ""
    });

    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 '{
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "WindowTargetId": "",\n  "Safe": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "WindowTargetId": "",
  "Safe": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTargetFromMaintenanceWindow")! 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=AmazonSSM.DeregisterTaskFromMaintenanceWindow");

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  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:WindowId ""
                                                                                                                      :WindowTaskId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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=AmazonSSM.DeregisterTaskFromMaintenanceWindow"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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=AmazonSSM.DeregisterTaskFromMaintenanceWindow");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "WindowId": "",
  "WindowTaskId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow")
  .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=AmazonSSM.DeregisterTaskFromMaintenanceWindow")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  WindowTaskId: ''
});

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=AmazonSSM.DeregisterTaskFromMaintenanceWindow');
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=AmazonSSM.DeregisterTaskFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', WindowTaskId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","WindowTaskId":""}'
};

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=AmazonSSM.DeregisterTaskFromMaintenanceWindow',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "WindowTaskId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow")
  .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({WindowId: '', WindowTaskId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowId: '', WindowTaskId: ''},
  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=AmazonSSM.DeregisterTaskFromMaintenanceWindow');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  WindowTaskId: ''
});

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=AmazonSSM.DeregisterTaskFromMaintenanceWindow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', WindowTaskId: ''}
};

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=AmazonSSM.DeregisterTaskFromMaintenanceWindow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","WindowTaskId":""}'
};

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 = @{ @"WindowId": @"",
                              @"WindowTaskId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow"]
                                                       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=AmazonSSM.DeregisterTaskFromMaintenanceWindow" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow",
  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([
    'WindowId' => '',
    'WindowTaskId' => ''
  ]),
  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=AmazonSSM.DeregisterTaskFromMaintenanceWindow', [
  'body' => '{
  "WindowId": "",
  "WindowTaskId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'WindowTaskId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'WindowTaskId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow');
$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=AmazonSSM.DeregisterTaskFromMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "WindowTaskId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "WindowTaskId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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=AmazonSSM.DeregisterTaskFromMaintenanceWindow"

payload = {
    "WindowId": "",
    "WindowTaskId": ""
}
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=AmazonSSM.DeregisterTaskFromMaintenanceWindow"

payload <- "{\n  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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=AmazonSSM.DeregisterTaskFromMaintenanceWindow")

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  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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  \"WindowId\": \"\",\n  \"WindowTaskId\": \"\"\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=AmazonSSM.DeregisterTaskFromMaintenanceWindow";

    let payload = json!({
        "WindowId": "",
        "WindowTaskId": ""
    });

    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 '{
  "WindowId": "",
  "WindowTaskId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "WindowTaskId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "WindowTaskId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DeregisterTaskFromMaintenanceWindow")! 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=AmazonSSM.DescribeActivations");

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:Filters ""
                                                                                                      :MaxResults ""
                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations")
  .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=AmazonSSM.DescribeActivations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations');
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=AmazonSSM.DescribeActivations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations")
  .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: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"]
                                                       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=AmazonSSM.DescribeActivations" 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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations",
  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' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations', [
  'body' => '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations');
$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=AmazonSSM.DescribeActivations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"

payload = {
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations")

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations";

    let payload = json!({
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations' \
  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  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeActivations")! 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=AmazonSSM.DescribeAssociation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:Name ""
                                                                                                      :InstanceId ""
                                                                                                      :AssociationId ""
                                                                                                      :AssociationVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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=AmazonSSM.DescribeAssociation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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=AmazonSSM.DescribeAssociation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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

{
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation")
  .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=AmazonSSM.DescribeAssociation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  InstanceId: '',
  AssociationId: '',
  AssociationVersion: ''
});

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=AmazonSSM.DescribeAssociation');
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=AmazonSSM.DescribeAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', InstanceId: '', AssociationId: '', AssociationVersion: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","InstanceId":"","AssociationId":"","AssociationVersion":""}'
};

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=AmazonSSM.DescribeAssociation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "InstanceId": "",\n  "AssociationId": "",\n  "AssociationVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', InstanceId: '', AssociationId: '', AssociationVersion: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', InstanceId: '', AssociationId: '', AssociationVersion: ''},
  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=AmazonSSM.DescribeAssociation');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  InstanceId: '',
  AssociationId: '',
  AssociationVersion: ''
});

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=AmazonSSM.DescribeAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', InstanceId: '', AssociationId: '', AssociationVersion: ''}
};

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=AmazonSSM.DescribeAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","InstanceId":"","AssociationId":"","AssociationVersion":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"InstanceId": @"",
                              @"AssociationId": @"",
                              @"AssociationVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation"]
                                                       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=AmazonSSM.DescribeAssociation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'InstanceId' => '',
    'AssociationId' => '',
    'AssociationVersion' => ''
  ]),
  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=AmazonSSM.DescribeAssociation', [
  'body' => '{
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'InstanceId' => '',
  'AssociationId' => '',
  'AssociationVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'InstanceId' => '',
  'AssociationId' => '',
  'AssociationVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation');
$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=AmazonSSM.DescribeAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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=AmazonSSM.DescribeAssociation"

payload = {
    "Name": "",
    "InstanceId": "",
    "AssociationId": "",
    "AssociationVersion": ""
}
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=AmazonSSM.DescribeAssociation"

payload <- "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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=AmazonSSM.DescribeAssociation")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"InstanceId\": \"\",\n  \"AssociationId\": \"\",\n  \"AssociationVersion\": \"\"\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=AmazonSSM.DescribeAssociation";

    let payload = json!({
        "Name": "",
        "InstanceId": "",
        "AssociationId": "",
        "AssociationVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "InstanceId": "",\n  "AssociationId": "",\n  "AssociationVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "InstanceId": "",
  "AssociationId": "",
  "AssociationVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociation")! 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=AmazonSSM.DescribeAssociationExecutionTargets");

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  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:AssociationId ""
                                                                                                                      :ExecutionId ""
                                                                                                                      :Filters ""
                                                                                                                      :MaxResults ""
                                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"

	payload := strings.NewReader("{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets")
  .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=AmazonSSM.DescribeAssociationExecutionTargets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssociationId: '',
  ExecutionId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets');
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=AmazonSSM.DescribeAssociationExecutionTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssociationId: '', ExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssociationId":"","ExecutionId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssociationId": "",\n  "ExecutionId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets")
  .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({AssociationId: '', ExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssociationId: '', ExecutionId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AssociationId: '',
  ExecutionId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssociationId: '', ExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssociationId":"","ExecutionId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssociationId": @"",
                              @"ExecutionId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"]
                                                       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=AmazonSSM.DescribeAssociationExecutionTargets" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets",
  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([
    'AssociationId' => '',
    'ExecutionId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets', [
  'body' => '{
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssociationId' => '',
  'ExecutionId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AssociationId' => '',
  'ExecutionId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets');
$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=AmazonSSM.DescribeAssociationExecutionTargets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"

payload = {
    "AssociationId": "",
    "ExecutionId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets"

payload <- "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets")

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  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssociationId\": \"\",\n  \"ExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets";

    let payload = json!({
        "AssociationId": "",
        "ExecutionId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssociationId": "",\n  "ExecutionId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AssociationId": "",
  "ExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutionTargets")! 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=AmazonSSM.DescribeAssociationExecutions");

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  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:AssociationId ""
                                                                                                                :Filters ""
                                                                                                                :MaxResults ""
                                                                                                                :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"

	payload := strings.NewReader("{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions")
  .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=AmazonSSM.DescribeAssociationExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AssociationId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions');
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=AmazonSSM.DescribeAssociationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssociationId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssociationId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AssociationId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions")
  .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({AssociationId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AssociationId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AssociationId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AssociationId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AssociationId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AssociationId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"]
                                                       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=AmazonSSM.DescribeAssociationExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions",
  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([
    'AssociationId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions', [
  'body' => '{
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AssociationId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AssociationId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions');
$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=AmazonSSM.DescribeAssociationExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"

payload = {
    "AssociationId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions"

payload <- "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions")

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  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AssociationId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions";

    let payload = json!({
        "AssociationId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AssociationId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AssociationId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAssociationExecutions")! 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=AmazonSSM.DescribeAutomationExecutions");

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:Filters ""
                                                                                                               :MaxResults ""
                                                                                                               :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions")
  .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=AmazonSSM.DescribeAutomationExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions');
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=AmazonSSM.DescribeAutomationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions")
  .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: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"]
                                                       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=AmazonSSM.DescribeAutomationExecutions" 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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions",
  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' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions', [
  'body' => '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions');
$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=AmazonSSM.DescribeAutomationExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"

payload = {
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions")

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions";

    let payload = json!({
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions' \
  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  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationExecutions")! 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=AmazonSSM.DescribeAutomationStepExecutions");

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  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:AutomationExecutionId ""
                                                                                                                   :Filters ""
                                                                                                                   :NextToken ""
                                                                                                                   :MaxResults ""
                                                                                                                   :ReverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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=AmazonSSM.DescribeAutomationStepExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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=AmazonSSM.DescribeAutomationStepExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions"

	payload := strings.NewReader("{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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: 111

{
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions")
  .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=AmazonSSM.DescribeAutomationStepExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AutomationExecutionId: '',
  Filters: '',
  NextToken: '',
  MaxResults: '',
  ReverseOrder: ''
});

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=AmazonSSM.DescribeAutomationStepExecutions');
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=AmazonSSM.DescribeAutomationStepExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutomationExecutionId: '',
    Filters: '',
    NextToken: '',
    MaxResults: '',
    ReverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutomationExecutionId":"","Filters":"","NextToken":"","MaxResults":"","ReverseOrder":""}'
};

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=AmazonSSM.DescribeAutomationStepExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutomationExecutionId": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "ReverseOrder": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions")
  .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({
  AutomationExecutionId: '',
  Filters: '',
  NextToken: '',
  MaxResults: '',
  ReverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AutomationExecutionId: '',
    Filters: '',
    NextToken: '',
    MaxResults: '',
    ReverseOrder: ''
  },
  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=AmazonSSM.DescribeAutomationStepExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AutomationExecutionId: '',
  Filters: '',
  NextToken: '',
  MaxResults: '',
  ReverseOrder: ''
});

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=AmazonSSM.DescribeAutomationStepExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AutomationExecutionId: '',
    Filters: '',
    NextToken: '',
    MaxResults: '',
    ReverseOrder: ''
  }
};

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=AmazonSSM.DescribeAutomationStepExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutomationExecutionId":"","Filters":"","NextToken":"","MaxResults":"","ReverseOrder":""}'
};

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 = @{ @"AutomationExecutionId": @"",
                              @"Filters": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"",
                              @"ReverseOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions"]
                                                       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=AmazonSSM.DescribeAutomationStepExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions",
  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([
    'AutomationExecutionId' => '',
    'Filters' => '',
    'NextToken' => '',
    'MaxResults' => '',
    'ReverseOrder' => ''
  ]),
  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=AmazonSSM.DescribeAutomationStepExecutions', [
  'body' => '{
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutomationExecutionId' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'ReverseOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AutomationExecutionId' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'ReverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions');
$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=AmazonSSM.DescribeAutomationStepExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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=AmazonSSM.DescribeAutomationStepExecutions"

payload = {
    "AutomationExecutionId": "",
    "Filters": "",
    "NextToken": "",
    "MaxResults": "",
    "ReverseOrder": ""
}
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=AmazonSSM.DescribeAutomationStepExecutions"

payload <- "{\n  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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=AmazonSSM.DescribeAutomationStepExecutions")

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  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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  \"AutomationExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"ReverseOrder\": \"\"\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=AmazonSSM.DescribeAutomationStepExecutions";

    let payload = json!({
        "AutomationExecutionId": "",
        "Filters": "",
        "NextToken": "",
        "MaxResults": "",
        "ReverseOrder": ""
    });

    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 '{
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutomationExecutionId": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "ReverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AutomationExecutionId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": "",
  "ReverseOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAutomationStepExecutions")! 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=AmazonSSM.DescribeAvailablePatches");

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:Filters ""
                                                                                                           :MaxResults ""
                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches")
  .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=AmazonSSM.DescribeAvailablePatches")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches');
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=AmazonSSM.DescribeAvailablePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches")
  .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: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"]
                                                       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=AmazonSSM.DescribeAvailablePatches" 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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches",
  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' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches', [
  'body' => '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches');
$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=AmazonSSM.DescribeAvailablePatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"

payload = {
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches")

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches";

    let payload = json!({
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches' \
  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  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeAvailablePatches")! 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=AmazonSSM.DescribeDocument");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument" {:headers {:x-amz-target ""}
                                                                                     :content-type :json
                                                                                     :form-params {:Name ""
                                                                                                   :DocumentVersion ""
                                                                                                   :VersionName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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=AmazonSSM.DescribeDocument"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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=AmazonSSM.DescribeDocument");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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: 62

{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument")
  .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=AmazonSSM.DescribeDocument")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  DocumentVersion: '',
  VersionName: ''
});

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=AmazonSSM.DescribeDocument');
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=AmazonSSM.DescribeDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', DocumentVersion: '', VersionName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","VersionName":""}'
};

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=AmazonSSM.DescribeDocument',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "DocumentVersion": "",\n  "VersionName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', DocumentVersion: '', VersionName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', DocumentVersion: '', VersionName: ''},
  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=AmazonSSM.DescribeDocument');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  DocumentVersion: '',
  VersionName: ''
});

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=AmazonSSM.DescribeDocument',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', DocumentVersion: '', VersionName: ''}
};

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=AmazonSSM.DescribeDocument';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","DocumentVersion":"","VersionName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"DocumentVersion": @"",
                              @"VersionName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument"]
                                                       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=AmazonSSM.DescribeDocument" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'DocumentVersion' => '',
    'VersionName' => ''
  ]),
  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=AmazonSSM.DescribeDocument', [
  'body' => '{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'DocumentVersion' => '',
  'VersionName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'DocumentVersion' => '',
  'VersionName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument');
$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=AmazonSSM.DescribeDocument' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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=AmazonSSM.DescribeDocument"

payload = {
    "Name": "",
    "DocumentVersion": "",
    "VersionName": ""
}
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=AmazonSSM.DescribeDocument"

payload <- "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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=AmazonSSM.DescribeDocument")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"DocumentVersion\": \"\",\n  \"VersionName\": \"\"\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=AmazonSSM.DescribeDocument";

    let payload = json!({
        "Name": "",
        "DocumentVersion": "",
        "VersionName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "DocumentVersion": "",\n  "VersionName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "DocumentVersion": "",
  "VersionName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocument")! 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=AmazonSSM.DescribeDocumentPermission");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:Name ""
                                                                                                             :PermissionType ""
                                                                                                             :MaxResults ""
                                                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 79

{
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission")
  .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=AmazonSSM.DescribeDocumentPermission")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  PermissionType: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission');
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=AmazonSSM.DescribeDocumentPermission',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', PermissionType: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","PermissionType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "PermissionType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Name: '', PermissionType: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', PermissionType: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  PermissionType: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', PermissionType: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","PermissionType":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"PermissionType": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"]
                                                       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=AmazonSSM.DescribeDocumentPermission" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'PermissionType' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission', [
  'body' => '{
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'PermissionType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'PermissionType' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission');
$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=AmazonSSM.DescribeDocumentPermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"

payload = {
    "Name": "",
    "PermissionType": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission"

payload <- "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"PermissionType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission";

    let payload = json!({
        "Name": "",
        "PermissionType": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "PermissionType": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "PermissionType": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeDocumentPermission")! 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=AmazonSSM.DescribeEffectiveInstanceAssociations");

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  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:InstanceId ""
                                                                                                                        :MaxResults ""
                                                                                                                        :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations")
  .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=AmazonSSM.DescribeEffectiveInstanceAssociations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations');
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=AmazonSSM.DescribeEffectiveInstanceAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations")
  .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({InstanceId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InstanceId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"]
                                                       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=AmazonSSM.DescribeEffectiveInstanceAssociations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations",
  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([
    'InstanceId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations', [
  'body' => '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations');
$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=AmazonSSM.DescribeEffectiveInstanceAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"

payload = {
    "InstanceId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations"

payload <- "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations")

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  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations";

    let payload = json!({
        "InstanceId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectiveInstanceAssociations")! 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=AmazonSSM.DescribeEffectivePatchesForPatchBaseline");

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  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:BaselineId ""
                                                                                                                           :MaxResults ""
                                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"

	payload := strings.NewReader("{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")
  .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=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  BaselineId: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline');
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=AmazonSSM.DescribeEffectivePatchesForPatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BaselineId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")
  .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({BaselineId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {BaselineId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BaselineId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {BaselineId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"BaselineId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"BaselineId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"]
                                                       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=AmazonSSM.DescribeEffectivePatchesForPatchBaseline" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline",
  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([
    'BaselineId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline', [
  'body' => '{
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BaselineId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BaselineId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline');
$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=AmazonSSM.DescribeEffectivePatchesForPatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"

payload = {
    "BaselineId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline"

payload <- "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")

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  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"BaselineId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline";

    let payload = json!({
        "BaselineId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "BaselineId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "BaselineId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeEffectivePatchesForPatchBaseline")! 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=AmazonSSM.DescribeInstanceAssociationsStatus");

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  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:InstanceId ""
                                                                                                                     :MaxResults ""
                                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus")
  .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=AmazonSSM.DescribeInstanceAssociationsStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus');
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=AmazonSSM.DescribeInstanceAssociationsStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus")
  .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({InstanceId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InstanceId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"]
                                                       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=AmazonSSM.DescribeInstanceAssociationsStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus",
  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([
    'InstanceId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus', [
  'body' => '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus');
$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=AmazonSSM.DescribeInstanceAssociationsStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"

payload = {
    "InstanceId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus"

payload <- "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus")

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  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InstanceId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus";

    let payload = json!({
        "InstanceId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InstanceId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceAssociationsStatus")! 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=AmazonSSM.DescribeInstanceInformation");

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  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:InstanceInformationFilterList ""
                                                                                                              :Filters ""
                                                                                                              :MaxResults ""
                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"

	payload := strings.NewReader("{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 97

{
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation")
  .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=AmazonSSM.DescribeInstanceInformation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceInformationFilterList: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation');
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=AmazonSSM.DescribeInstanceInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceInformationFilterList: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceInformationFilterList":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceInformationFilterList": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation")
  .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({InstanceInformationFilterList: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceInformationFilterList: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceInformationFilterList: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceInformationFilterList: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceInformationFilterList":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InstanceInformationFilterList": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"]
                                                       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=AmazonSSM.DescribeInstanceInformation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation",
  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([
    'InstanceInformationFilterList' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation', [
  'body' => '{
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceInformationFilterList' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceInformationFilterList' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation');
$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=AmazonSSM.DescribeInstanceInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"

payload = {
    "InstanceInformationFilterList": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation"

payload <- "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation")

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  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InstanceInformationFilterList\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation";

    let payload = json!({
        "InstanceInformationFilterList": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceInformationFilterList": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InstanceInformationFilterList": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstanceInformation")! 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=AmazonSSM.DescribeInstancePatchStates");

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  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:InstanceIds ""
                                                                                                              :NextToken ""
                                                                                                              :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"

	payload := strings.NewReader("{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 62

{
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates")
  .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=AmazonSSM.DescribeInstancePatchStates")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceIds: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates');
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=AmazonSSM.DescribeInstancePatchStates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceIds: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceIds":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceIds": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates")
  .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({InstanceIds: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceIds: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceIds: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceIds: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceIds":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InstanceIds": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"]
                                                       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=AmazonSSM.DescribeInstancePatchStates" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates",
  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([
    'InstanceIds' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates', [
  'body' => '{
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceIds' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceIds' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates');
$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=AmazonSSM.DescribeInstancePatchStates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"

payload = {
    "InstanceIds": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates"

payload <- "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates")

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  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InstanceIds\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates";

    let payload = json!({
        "InstanceIds": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceIds": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InstanceIds": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStates")! 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=AmazonSSM.DescribeInstancePatchStatesForPatchGroup");

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  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:PatchGroup ""
                                                                                                                           :Filters ""
                                                                                                                           :NextToken ""
                                                                                                                           :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"

	payload := strings.NewReader("{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")
  .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=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PatchGroup: '',
  Filters: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup');
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=AmazonSSM.DescribeInstancePatchStatesForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PatchGroup: '', Filters: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PatchGroup":"","Filters":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PatchGroup": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")
  .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({PatchGroup: '', Filters: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PatchGroup: '', Filters: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PatchGroup: '',
  Filters: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PatchGroup: '', Filters: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PatchGroup":"","Filters":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PatchGroup": @"",
                              @"Filters": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"]
                                                       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=AmazonSSM.DescribeInstancePatchStatesForPatchGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup",
  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([
    'PatchGroup' => '',
    'Filters' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup', [
  'body' => '{
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PatchGroup' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PatchGroup' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup');
$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=AmazonSSM.DescribeInstancePatchStatesForPatchGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"

payload = {
    "PatchGroup": "",
    "Filters": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup"

payload <- "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")

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  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PatchGroup\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup";

    let payload = json!({
        "PatchGroup": "",
        "Filters": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PatchGroup": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PatchGroup": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatchStatesForPatchGroup")! 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=AmazonSSM.DescribeInstancePatches");

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  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:InstanceId ""
                                                                                                          :Filters ""
                                                                                                          :NextToken ""
                                                                                                          :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"

	payload := strings.NewReader("{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches")
  .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=AmazonSSM.DescribeInstancePatches")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InstanceId: '',
  Filters: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches');
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=AmazonSSM.DescribeInstancePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', Filters: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","Filters":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InstanceId": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches")
  .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({InstanceId: '', Filters: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InstanceId: '', Filters: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InstanceId: '',
  Filters: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InstanceId: '', Filters: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InstanceId":"","Filters":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InstanceId": @"",
                              @"Filters": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"]
                                                       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=AmazonSSM.DescribeInstancePatches" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches",
  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([
    'InstanceId' => '',
    'Filters' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches', [
  'body' => '{
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InstanceId' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InstanceId' => '',
  'Filters' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches');
$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=AmazonSSM.DescribeInstancePatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"

payload = {
    "InstanceId": "",
    "Filters": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches"

payload <- "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches")

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  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InstanceId\": \"\",\n  \"Filters\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches";

    let payload = json!({
        "InstanceId": "",
        "Filters": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InstanceId": "",\n  "Filters": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InstanceId": "",
  "Filters": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInstancePatches")! 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=AmazonSSM.DescribeInventoryDeletions");

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  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:DeletionId ""
                                                                                                             :NextToken ""
                                                                                                             :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"

	payload := strings.NewReader("{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions")
  .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=AmazonSSM.DescribeInventoryDeletions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeletionId: '',
  NextToken: '',
  MaxResults: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions');
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=AmazonSSM.DescribeInventoryDeletions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeletionId: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeletionId":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeletionId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions")
  .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({DeletionId: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DeletionId: '', NextToken: '', MaxResults: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DeletionId: '',
  NextToken: '',
  MaxResults: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DeletionId: '', NextToken: '', MaxResults: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DeletionId":"","NextToken":"","MaxResults":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DeletionId": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"]
                                                       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=AmazonSSM.DescribeInventoryDeletions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions",
  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([
    'DeletionId' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions', [
  'body' => '{
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeletionId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DeletionId' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions');
$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=AmazonSSM.DescribeInventoryDeletions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"

payload = {
    "DeletionId": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions"

payload <- "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions")

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  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DeletionId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions";

    let payload = json!({
        "DeletionId": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeletionId": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DeletionId": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeInventoryDeletions")! 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=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations");

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  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:WindowExecutionId ""
                                                                                                                                    :TaskId ""
                                                                                                                                    :Filters ""
                                                                                                                                    :MaxResults ""
                                                                                                                                    :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"

	payload := strings.NewReader("{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 101

{
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")
  .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=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowExecutionId: '',
  TaskId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations');
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=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowExecutionId: '', TaskId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowExecutionId":"","TaskId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowExecutionId": "",\n  "TaskId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")
  .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({WindowExecutionId: '', TaskId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowExecutionId: '', TaskId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowExecutionId: '',
  TaskId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowExecutionId: '', TaskId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowExecutionId":"","TaskId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowExecutionId": @"",
                              @"TaskId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations",
  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([
    'WindowExecutionId' => '',
    'TaskId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations', [
  'body' => '{
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowExecutionId' => '',
  'TaskId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowExecutionId' => '',
  'TaskId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations');
$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=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"

payload = {
    "WindowExecutionId": "",
    "TaskId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations"

payload <- "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")

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  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowExecutionId\": \"\",\n  \"TaskId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations";

    let payload = json!({
        "WindowExecutionId": "",
        "TaskId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowExecutionId": "",\n  "TaskId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowExecutionId": "",
  "TaskId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTaskInvocations")! 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=AmazonSSM.DescribeMaintenanceWindowExecutionTasks");

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  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:WindowExecutionId ""
                                                                                                                          :Filters ""
                                                                                                                          :MaxResults ""
                                                                                                                          :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"

	payload := strings.NewReader("{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 85

{
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")
  .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=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowExecutionId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks');
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=AmazonSSM.DescribeMaintenanceWindowExecutionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowExecutionId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowExecutionId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")
  .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({WindowExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowExecutionId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowExecutionId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowExecutionId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowExecutionId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowExecutionId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowExecutionTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks",
  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([
    'WindowExecutionId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks', [
  'body' => '{
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowExecutionId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowExecutionId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks');
$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=AmazonSSM.DescribeMaintenanceWindowExecutionTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"

payload = {
    "WindowExecutionId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks"

payload <- "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")

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  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowExecutionId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks";

    let payload = json!({
        "WindowExecutionId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowExecutionId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowExecutionId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutionTasks")! 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=AmazonSSM.DescribeMaintenanceWindowExecutions");

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:WindowId ""
                                                                                                                      :Filters ""
                                                                                                                      :MaxResults ""
                                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions")
  .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=AmazonSSM.DescribeMaintenanceWindowExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions');
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=AmazonSSM.DescribeMaintenanceWindowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions")
  .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({WindowId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions",
  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([
    'WindowId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions', [
  'body' => '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions');
$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=AmazonSSM.DescribeMaintenanceWindowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"

payload = {
    "WindowId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions"

payload <- "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions")

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions";

    let payload = json!({
        "WindowId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowExecutions")! 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=AmazonSSM.DescribeMaintenanceWindowSchedule");

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  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:WindowId ""
                                                                                                                    :Targets ""
                                                                                                                    :ResourceType ""
                                                                                                                    :Filters ""
                                                                                                                    :MaxResults ""
                                                                                                                    :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 115

{
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule")
  .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=AmazonSSM.DescribeMaintenanceWindowSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  Targets: '',
  ResourceType: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule');
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=AmazonSSM.DescribeMaintenanceWindowSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WindowId: '',
    Targets: '',
    ResourceType: '',
    Filters: '',
    MaxResults: '',
    NextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Targets":"","ResourceType":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "Targets": "",\n  "ResourceType": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule")
  .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({
  WindowId: '',
  Targets: '',
  ResourceType: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    WindowId: '',
    Targets: '',
    ResourceType: '',
    Filters: '',
    MaxResults: '',
    NextToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  Targets: '',
  ResourceType: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    WindowId: '',
    Targets: '',
    ResourceType: '',
    Filters: '',
    MaxResults: '',
    NextToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Targets":"","ResourceType":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowId": @"",
                              @"Targets": @"",
                              @"ResourceType": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule",
  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([
    'WindowId' => '',
    'Targets' => '',
    'ResourceType' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule', [
  'body' => '{
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'Targets' => '',
  'ResourceType' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'Targets' => '',
  'ResourceType' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule');
$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=AmazonSSM.DescribeMaintenanceWindowSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"

payload = {
    "WindowId": "",
    "Targets": "",
    "ResourceType": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule"

payload <- "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule")

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  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowId\": \"\",\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule";

    let payload = json!({
        "WindowId": "",
        "Targets": "",
        "ResourceType": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "Targets": "",\n  "ResourceType": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "Targets": "",
  "ResourceType": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowSchedule")! 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=AmazonSSM.DescribeMaintenanceWindowTargets");

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:WindowId ""
                                                                                                                   :Filters ""
                                                                                                                   :MaxResults ""
                                                                                                                   :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets")
  .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=AmazonSSM.DescribeMaintenanceWindowTargets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets');
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=AmazonSSM.DescribeMaintenanceWindowTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets")
  .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({WindowId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowTargets" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets",
  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([
    'WindowId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets', [
  'body' => '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets');
$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=AmazonSSM.DescribeMaintenanceWindowTargets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"

payload = {
    "WindowId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets"

payload <- "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets")

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets";

    let payload = json!({
        "WindowId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTargets")! 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=AmazonSSM.DescribeMaintenanceWindowTasks");

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:WindowId ""
                                                                                                                 :Filters ""
                                                                                                                 :MaxResults ""
                                                                                                                 :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"

	payload := strings.NewReader("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks")
  .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=AmazonSSM.DescribeMaintenanceWindowTasks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks');
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=AmazonSSM.DescribeMaintenanceWindowTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks")
  .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({WindowId: '', Filters: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  WindowId: '',
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {WindowId: '', Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"WindowId":"","Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"WindowId": @"",
                              @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"]
                                                       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=AmazonSSM.DescribeMaintenanceWindowTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks",
  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([
    'WindowId' => '',
    'Filters' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks', [
  'body' => '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'WindowId' => '',
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks');
$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=AmazonSSM.DescribeMaintenanceWindowTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"

payload = {
    "WindowId": "",
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks"

payload <- "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks")

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  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"WindowId\": \"\",\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks";

    let payload = json!({
        "WindowId": "",
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "WindowId": "",\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "WindowId": "",
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowTasks")! 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=AmazonSSM.DescribeMaintenanceWindows");

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:Filters ""
                                                                                                             :MaxResults ""
                                                                                                             :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"

	payload := strings.NewReader("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows")
  .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=AmazonSSM.DescribeMaintenanceWindows")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows');
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=AmazonSSM.DescribeMaintenanceWindows',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows")
  .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: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Filters: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Filters: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Filters: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filters":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Filters": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"]
                                                       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=AmazonSSM.DescribeMaintenanceWindows" 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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows",
  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' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows', [
  'body' => '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Filters' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows');
$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=AmazonSSM.DescribeMaintenanceWindows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"

payload = {
    "Filters": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows"

payload <- "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows")

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Filters\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows";

    let payload = json!({
        "Filters": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows' \
  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  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filters": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindows")! 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=AmazonSSM.DescribeMaintenanceWindowsForTarget");

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  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:Targets ""
                                                                                                                      :ResourceType ""
                                                                                                                      :MaxResults ""
                                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget"

	payload := strings.NewReader("{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 80

{
  "Targets": "",
  "ResourceType": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AmazonSSM.DescribeMaintenanceWindowsForTarget"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Targets\": \"\",\n  \"ResourceType\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());