CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/accept-certificate-transfer/:certificateId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/accept-certificate-transfer/:certificateId")

require "http/client"

url = "{{baseUrl}}/accept-certificate-transfer/:certificateId"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/accept-certificate-transfer/:certificateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/accept-certificate-transfer/:certificateId");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/accept-certificate-transfer/:certificateId"

	req, _ := http.NewRequest("PATCH", url, nil)

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

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

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

}

PATCH /baseUrl/accept-certificate-transfer/:certificateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/accept-certificate-transfer/:certificateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/accept-certificate-transfer/:certificateId"))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/accept-certificate-transfer/:certificateId")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/accept-certificate-transfer/:certificateId")
  .asString();

const data = null;

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

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

xhr.open('PATCH', '{{baseUrl}}/accept-certificate-transfer/:certificateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/accept-certificate-transfer/:certificateId'
};

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

const url = '{{baseUrl}}/accept-certificate-transfer/:certificateId';
const options = {method: 'PATCH'};

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}}/accept-certificate-transfer/:certificateId',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/accept-certificate-transfer/:certificateId")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/accept-certificate-transfer/:certificateId',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/accept-certificate-transfer/:certificateId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/accept-certificate-transfer/:certificateId');

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/accept-certificate-transfer/:certificateId'
};

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

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

const url = '{{baseUrl}}/accept-certificate-transfer/:certificateId';
const options = {method: 'PATCH'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/accept-certificate-transfer/:certificateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/accept-certificate-transfer/:certificateId" in

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

 "{{baseUrl}}/accept-certificate-transfer/:certificateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/accept-certificate-transfer/:certificateId');

echo $response->getBody();

setUrl('{{baseUrl}}/accept-certificate-transfer/:certificateId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/accept-certificate-transfer/:certificateId');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/accept-certificate-transfer/:certificateId' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/accept-certificate-transfer/:certificateId' -Method PATCH 

import http.client

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

conn.request("PATCH", "/baseUrl/accept-certificate-transfer/:certificateId")

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

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

import requests

url = "{{baseUrl}}/accept-certificate-transfer/:certificateId"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/accept-certificate-transfer/:certificateId"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/accept-certificate-transfer/:certificateId")

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

request = Net::HTTP::Patch.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/accept-certificate-transfer/:certificateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/accept-certificate-transfer/:certificateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http PATCH {{baseUrl}}/accept-certificate-transfer/:certificateId

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/accept-certificate-transfer/:certificateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/accept-certificate-transfer/:certificateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing-groups/addThingToBillingGroup");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/billing-groups/addThingToBillingGroup" {:content-type :json
                                                                                 :form-params {:billingGroupName ""
                                                                                               :billingGroupArn ""
                                                                                               :thingName ""
                                                                                               :thingArn ""}})

require "http/client"

url = "{{baseUrl}}/billing-groups/addThingToBillingGroup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/billing-groups/addThingToBillingGroup"),
    Content = new StringContent("{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\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}}/billing-groups/addThingToBillingGroup");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/billing-groups/addThingToBillingGroup"

	payload := strings.NewReader("{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}")

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

	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))

}

PUT /baseUrl/billing-groups/addThingToBillingGroup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/billing-groups/addThingToBillingGroup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing-groups/addThingToBillingGroup"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\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  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/billing-groups/addThingToBillingGroup")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/billing-groups/addThingToBillingGroup")
  .header("content-type", "application/json")
  .body("{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  billingGroupName: '',
  billingGroupArn: '',
  thingName: '',
  thingArn: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/billing-groups/addThingToBillingGroup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/billing-groups/addThingToBillingGroup',
  headers: {'content-type': 'application/json'},
  data: {billingGroupName: '', billingGroupArn: '', thingName: '', thingArn: ''}
};

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

const url = '{{baseUrl}}/billing-groups/addThingToBillingGroup';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"billingGroupName":"","billingGroupArn":"","thingName":"","thingArn":""}'
};

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}}/billing-groups/addThingToBillingGroup',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "billingGroupName": "",\n  "billingGroupArn": "",\n  "thingName": "",\n  "thingArn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/billing-groups/addThingToBillingGroup")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing-groups/addThingToBillingGroup',
  headers: {
    '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({billingGroupName: '', billingGroupArn: '', thingName: '', thingArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/billing-groups/addThingToBillingGroup',
  headers: {'content-type': 'application/json'},
  body: {billingGroupName: '', billingGroupArn: '', thingName: '', thingArn: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/billing-groups/addThingToBillingGroup');

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

req.type('json');
req.send({
  billingGroupName: '',
  billingGroupArn: '',
  thingName: '',
  thingArn: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/billing-groups/addThingToBillingGroup',
  headers: {'content-type': 'application/json'},
  data: {billingGroupName: '', billingGroupArn: '', thingName: '', thingArn: ''}
};

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

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

const url = '{{baseUrl}}/billing-groups/addThingToBillingGroup';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"billingGroupName":"","billingGroupArn":"","thingName":"","thingArn":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"billingGroupName": @"",
                              @"billingGroupArn": @"",
                              @"thingName": @"",
                              @"thingArn": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing-groups/addThingToBillingGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/billing-groups/addThingToBillingGroup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}" in

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

 "{{baseUrl}}/billing-groups/addThingToBillingGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'billingGroupName' => '',
    'billingGroupArn' => '',
    'thingName' => '',
    'thingArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/billing-groups/addThingToBillingGroup', [
  'body' => '{
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/billing-groups/addThingToBillingGroup');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'billingGroupName' => '',
  'billingGroupArn' => '',
  'thingName' => '',
  'thingArn' => ''
]));

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

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

append(json_encode([
  'billingGroupName' => '',
  'billingGroupArn' => '',
  'thingName' => '',
  'thingArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/billing-groups/addThingToBillingGroup');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing-groups/addThingToBillingGroup' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing-groups/addThingToBillingGroup' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
}'

import http.client

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

payload = "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/billing-groups/addThingToBillingGroup", payload, headers)

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

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

import requests

url = "{{baseUrl}}/billing-groups/addThingToBillingGroup"

payload = {
    "billingGroupName": "",
    "billingGroupArn": "",
    "thingName": "",
    "thingArn": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing-groups/addThingToBillingGroup"

payload <- "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing-groups/addThingToBillingGroup")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\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.put('/baseUrl/billing-groups/addThingToBillingGroup') do |req|
  req.body = "{\n  \"billingGroupName\": \"\",\n  \"billingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/billing-groups/addThingToBillingGroup";

    let payload = json!({
        "billingGroupName": "",
        "billingGroupArn": "",
        "thingName": "",
        "thingArn": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
}' |  \
  http PUT {{baseUrl}}/billing-groups/addThingToBillingGroup \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "billingGroupName": "",\n  "billingGroupArn": "",\n  "thingName": "",\n  "thingArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/billing-groups/addThingToBillingGroup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "billingGroupName": "",
  "billingGroupArn": "",
  "thingName": "",
  "thingArn": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/billing-groups/addThingToBillingGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/thing-groups/addThingToThingGroup");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/thing-groups/addThingToThingGroup" {:content-type :json
                                                                             :form-params {:thingGroupName ""
                                                                                           :thingGroupArn ""
                                                                                           :thingName ""
                                                                                           :thingArn ""
                                                                                           :overrideDynamicGroups false}})

require "http/client"

url = "{{baseUrl}}/thing-groups/addThingToThingGroup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/thing-groups/addThingToThingGroup"),
    Content = new StringContent("{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\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}}/thing-groups/addThingToThingGroup");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/thing-groups/addThingToThingGroup"

	payload := strings.NewReader("{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}")

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

	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))

}

PUT /baseUrl/thing-groups/addThingToThingGroup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 120

{
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/thing-groups/addThingToThingGroup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/thing-groups/addThingToThingGroup"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\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  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/thing-groups/addThingToThingGroup")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/thing-groups/addThingToThingGroup")
  .header("content-type", "application/json")
  .body("{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}")
  .asString();

const data = JSON.stringify({
  thingGroupName: '',
  thingGroupArn: '',
  thingName: '',
  thingArn: '',
  overrideDynamicGroups: false
});

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

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

xhr.open('PUT', '{{baseUrl}}/thing-groups/addThingToThingGroup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/thing-groups/addThingToThingGroup',
  headers: {'content-type': 'application/json'},
  data: {
    thingGroupName: '',
    thingGroupArn: '',
    thingName: '',
    thingArn: '',
    overrideDynamicGroups: false
  }
};

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

const url = '{{baseUrl}}/thing-groups/addThingToThingGroup';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"thingGroupName":"","thingGroupArn":"","thingName":"","thingArn":"","overrideDynamicGroups":false}'
};

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}}/thing-groups/addThingToThingGroup',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "thingGroupName": "",\n  "thingGroupArn": "",\n  "thingName": "",\n  "thingArn": "",\n  "overrideDynamicGroups": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/thing-groups/addThingToThingGroup")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/thing-groups/addThingToThingGroup',
  headers: {
    '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({
  thingGroupName: '',
  thingGroupArn: '',
  thingName: '',
  thingArn: '',
  overrideDynamicGroups: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/thing-groups/addThingToThingGroup',
  headers: {'content-type': 'application/json'},
  body: {
    thingGroupName: '',
    thingGroupArn: '',
    thingName: '',
    thingArn: '',
    overrideDynamicGroups: false
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/thing-groups/addThingToThingGroup');

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

req.type('json');
req.send({
  thingGroupName: '',
  thingGroupArn: '',
  thingName: '',
  thingArn: '',
  overrideDynamicGroups: false
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/thing-groups/addThingToThingGroup',
  headers: {'content-type': 'application/json'},
  data: {
    thingGroupName: '',
    thingGroupArn: '',
    thingName: '',
    thingArn: '',
    overrideDynamicGroups: false
  }
};

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

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

const url = '{{baseUrl}}/thing-groups/addThingToThingGroup';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"thingGroupName":"","thingGroupArn":"","thingName":"","thingArn":"","overrideDynamicGroups":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"thingGroupName": @"",
                              @"thingGroupArn": @"",
                              @"thingName": @"",
                              @"thingArn": @"",
                              @"overrideDynamicGroups": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/thing-groups/addThingToThingGroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/thing-groups/addThingToThingGroup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}" in

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

 "{{baseUrl}}/thing-groups/addThingToThingGroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'thingGroupName' => '',
    'thingGroupArn' => '',
    'thingName' => '',
    'thingArn' => '',
    'overrideDynamicGroups' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/thing-groups/addThingToThingGroup', [
  'body' => '{
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/thing-groups/addThingToThingGroup');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'thingGroupName' => '',
  'thingGroupArn' => '',
  'thingName' => '',
  'thingArn' => '',
  'overrideDynamicGroups' => null
]));

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

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

append(json_encode([
  'thingGroupName' => '',
  'thingGroupArn' => '',
  'thingName' => '',
  'thingArn' => '',
  'overrideDynamicGroups' => null
]));
$request->setRequestUrl('{{baseUrl}}/thing-groups/addThingToThingGroup');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/thing-groups/addThingToThingGroup' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/thing-groups/addThingToThingGroup' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
}'

import http.client

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

payload = "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/thing-groups/addThingToThingGroup", payload, headers)

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

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

import requests

url = "{{baseUrl}}/thing-groups/addThingToThingGroup"

payload = {
    "thingGroupName": "",
    "thingGroupArn": "",
    "thingName": "",
    "thingArn": "",
    "overrideDynamicGroups": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/thing-groups/addThingToThingGroup"

payload <- "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/thing-groups/addThingToThingGroup")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\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.put('/baseUrl/thing-groups/addThingToThingGroup') do |req|
  req.body = "{\n  \"thingGroupName\": \"\",\n  \"thingGroupArn\": \"\",\n  \"thingName\": \"\",\n  \"thingArn\": \"\",\n  \"overrideDynamicGroups\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/thing-groups/addThingToThingGroup";

    let payload = json!({
        "thingGroupName": "",
        "thingGroupArn": "",
        "thingName": "",
        "thingArn": "",
        "overrideDynamicGroups": false
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
}' |  \
  http PUT {{baseUrl}}/thing-groups/addThingToThingGroup \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "thingGroupName": "",\n  "thingGroupArn": "",\n  "thingName": "",\n  "thingArn": "",\n  "overrideDynamicGroups": false\n}' \
  --output-document \
  - {{baseUrl}}/thing-groups/addThingToThingGroup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "thingGroupName": "",
  "thingGroupArn": "",
  "thingName": "",
  "thingArn": "",
  "overrideDynamicGroups": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/thing-groups/addThingToThingGroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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}}/jobs/:jobId/targets");

struct curl_slist *headers = NULL;
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  \"comment\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/jobs/:jobId/targets" {:content-type :json
                                                                :form-params {:targets []
                                                                              :comment ""}})

require "http/client"

url = "{{baseUrl}}/jobs/:jobId/targets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"targets\": [],\n  \"comment\": \"\"\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}}/jobs/:jobId/targets"),
    Content = new StringContent("{\n  \"targets\": [],\n  \"comment\": \"\"\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}}/jobs/:jobId/targets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"targets\": [],\n  \"comment\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/jobs/:jobId/targets"

	payload := strings.NewReader("{\n  \"targets\": [],\n  \"comment\": \"\"\n}")

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

	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/jobs/:jobId/targets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "targets": [],
  "comment": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/jobs/:jobId/targets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"targets\": [],\n  \"comment\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs/:jobId/targets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"targets\": [],\n  \"comment\": \"\"\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  \"targets\": [],\n  \"comment\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId/targets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/jobs/:jobId/targets")
  .header("content-type", "application/json")
  .body("{\n  \"targets\": [],\n  \"comment\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  targets: [],
  comment: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/jobs/:jobId/targets');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/jobs/:jobId/targets',
  headers: {'content-type': 'application/json'},
  data: {targets: [], comment: ''}
};

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

const url = '{{baseUrl}}/jobs/:jobId/targets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"targets":[],"comment":""}'
};

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}}/jobs/:jobId/targets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "targets": [],\n  "comment": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"targets\": [],\n  \"comment\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId/targets")
  .post(body)
  .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/jobs/:jobId/targets',
  headers: {
    '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({targets: [], comment: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/jobs/:jobId/targets',
  headers: {'content-type': 'application/json'},
  body: {targets: [], comment: ''},
  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}}/jobs/:jobId/targets');

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

req.type('json');
req.send({
  targets: [],
  comment: ''
});

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}}/jobs/:jobId/targets',
  headers: {'content-type': 'application/json'},
  data: {targets: [], comment: ''}
};

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

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

const url = '{{baseUrl}}/jobs/:jobId/targets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"targets":[],"comment":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"targets": @[  ],
                              @"comment": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/jobs/:jobId/targets"]
                                                       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}}/jobs/:jobId/targets" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"targets\": [],\n  \"comment\": \"\"\n}" in

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

 "{{baseUrl}}/jobs/:jobId/targets",
  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([
    'targets' => [
        
    ],
    'comment' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/jobs/:jobId/targets', [
  'body' => '{
  "targets": [],
  "comment": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/jobs/:jobId/targets');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'targets' => [
    
  ],
  'comment' => ''
]));
$request->setRequestUrl('{{baseUrl}}/jobs/:jobId/targets');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs/:jobId/targets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "targets": [],
  "comment": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs/:jobId/targets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "targets": [],
  "comment": ""
}'

import http.client

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

payload = "{\n  \"targets\": [],\n  \"comment\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/jobs/:jobId/targets", payload, headers)

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

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

import requests

url = "{{baseUrl}}/jobs/:jobId/targets"

payload = {
    "targets": [],
    "comment": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/jobs/:jobId/targets"

payload <- "{\n  \"targets\": [],\n  \"comment\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jobs/:jobId/targets")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"targets\": [],\n  \"comment\": \"\"\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/jobs/:jobId/targets') do |req|
  req.body = "{\n  \"targets\": [],\n  \"comment\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jobs/:jobId/targets";

    let payload = json!({
        "targets": (),
        "comment": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "targets": [],
  "comment": ""
}' |  \
  http POST {{baseUrl}}/jobs/:jobId/targets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "targets": [],\n  "comment": ""\n}' \
  --output-document \
  - {{baseUrl}}/jobs/:jobId/targets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "targets": [],
  "comment": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jobs/:jobId/targets")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/target-policies/:policyName");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/target-policies/:policyName" {:content-type :json
                                                                       :form-params {:target ""}})

require "http/client"

url = "{{baseUrl}}/target-policies/:policyName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"target\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/target-policies/:policyName"),
    Content = new StringContent("{\n  \"target\": \"\"\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}}/target-policies/:policyName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"target\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/target-policies/:policyName"

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

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

	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))

}

PUT /baseUrl/target-policies/:policyName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 18

{
  "target": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/target-policies/:policyName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"target\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/target-policies/:policyName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"target\": \"\"\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  \"target\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/target-policies/:policyName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/target-policies/:policyName")
  .header("content-type", "application/json")
  .body("{\n  \"target\": \"\"\n}")
  .asString();

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

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

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

xhr.open('PUT', '{{baseUrl}}/target-policies/:policyName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/target-policies/:policyName',
  headers: {'content-type': 'application/json'},
  data: {target: ''}
};

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

const url = '{{baseUrl}}/target-policies/:policyName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"target":""}'
};

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}}/target-policies/:policyName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "target": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"target\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/target-policies/:policyName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/target-policies/:policyName',
  headers: {
    '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({target: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/target-policies/:policyName',
  headers: {'content-type': 'application/json'},
  body: {target: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/target-policies/:policyName');

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

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

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/target-policies/:policyName',
  headers: {'content-type': 'application/json'},
  data: {target: ''}
};

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

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

const url = '{{baseUrl}}/target-policies/:policyName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"target":""}'
};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/target-policies/:policyName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/target-policies/:policyName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"target\": \"\"\n}" in

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

 "{{baseUrl}}/target-policies/:policyName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'target' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/target-policies/:policyName', [
  'body' => '{
  "target": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/target-policies/:policyName');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'target' => ''
]));
$request->setRequestUrl('{{baseUrl}}/target-policies/:policyName');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/target-policies/:policyName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "target": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/target-policies/:policyName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "target": ""
}'

import http.client

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

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

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/target-policies/:policyName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/target-policies/:policyName"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/target-policies/:policyName"

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

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/target-policies/:policyName")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"target\": \"\"\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.put('/baseUrl/target-policies/:policyName') do |req|
  req.body = "{\n  \"target\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/target-policies/:policyName";

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

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "target": ""
}' |  \
  http PUT {{baseUrl}}/target-policies/:policyName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "target": ""\n}' \
  --output-document \
  - {{baseUrl}}/target-policies/:policyName

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/target-policies/:policyName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amzn-iot-principal: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal" {:headers {:x-amzn-iot-principal ""}})

require "http/client"

url = "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"
headers = HTTP::Headers{
  "x-amzn-iot-principal" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"),
    Headers =
    {
        { "x-amzn-iot-principal", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-amzn-iot-principal", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("x-amzn-iot-principal", "")

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

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

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

}

PUT /baseUrl/principal-policies/:policyName HTTP/1.1
X-Amzn-Iot-Principal: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")
  .setHeader("x-amzn-iot-principal", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"))
    .header("x-amzn-iot-principal", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")
  .put(null)
  .addHeader("x-amzn-iot-principal", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")
  .header("x-amzn-iot-principal", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal');
xhr.setRequestHeader('x-amzn-iot-principal', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal',
  headers: {'x-amzn-iot-principal': ''}
};

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

const url = '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal';
const options = {method: 'PUT', headers: {'x-amzn-iot-principal': ''}};

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}}/principal-policies/:policyName#x-amzn-iot-principal',
  method: 'PUT',
  headers: {
    'x-amzn-iot-principal': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")
  .put(null)
  .addHeader("x-amzn-iot-principal", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/principal-policies/:policyName',
  headers: {
    'x-amzn-iot-principal': ''
  }
};

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.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal',
  headers: {'x-amzn-iot-principal': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal');

req.headers({
  'x-amzn-iot-principal': ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal',
  headers: {'x-amzn-iot-principal': ''}
};

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

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

const url = '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal';
const options = {method: 'PUT', headers: {'x-amzn-iot-principal': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amzn-iot-principal": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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}}/principal-policies/:policyName#x-amzn-iot-principal" in
let headers = Header.add (Header.init ()) "x-amzn-iot-principal" "" in

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

 "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-amzn-iot-principal: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal', [
  'headers' => [
    'x-amzn-iot-principal' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-amzn-iot-principal' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'x-amzn-iot-principal' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amzn-iot-principal", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-amzn-iot-principal", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-amzn-iot-principal': "" }

conn.request("PUT", "/baseUrl/principal-policies/:policyName", headers=headers)

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

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

import requests

url = "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"

headers = {"x-amzn-iot-principal": ""}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal"

response <- VERB("PUT", url, add_headers('x-amzn-iot-principal' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")

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

request = Net::HTTP::Put.new(url)
request["x-amzn-iot-principal"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/principal-policies/:policyName') do |req|
  req.headers['x-amzn-iot-principal'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amzn-iot-principal", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

http PUT '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal' \
  x-amzn-iot-principal:''

wget --quiet \
  --method PUT \
  --header 'x-amzn-iot-principal: ' \
  --output-document \
  - '{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal'

import Foundation

let headers = ["x-amzn-iot-principal": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/principal-policies/:policyName#x-amzn-iot-principal")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn" {:query-params {:securityProfileTargetArn ""}})

require "http/client"

url = "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/security-profiles/:securityProfileName/targets?securityProfileTargetArn= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn',
  params: {securityProfileTargetArn: ''}
};

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

const url = '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn';
const options = {method: 'PUT'};

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}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/security-profiles/:securityProfileName/targets?securityProfileTargetArn=',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn',
  qs: {securityProfileTargetArn: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn');

req.query({
  securityProfileTargetArn: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn',
  params: {securityProfileTargetArn: ''}
};

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

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

const url = '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn" in

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

 "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn');

echo $response->getBody();

setUrl('{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'securityProfileTargetArn' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'securityProfileTargetArn' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/security-profiles/:securityProfileName/targets?securityProfileTargetArn=")

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

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

import requests

url = "{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn"

querystring = {"securityProfileTargetArn":""}

response = requests.put(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn"

queryString <- list(securityProfileTargetArn = "")

response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/security-profiles/:securityProfileName/targets') do |req|
  req.params['securityProfileTargetArn'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security-profiles/:securityProfileName/targets#securityProfileTargetArn";

    let querystring = [
        ("securityProfileTargetArn", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

http PUT '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn'

wget --quiet \
  --method PUT \
  --output-document \
  - '{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security-profiles/:securityProfileName/targets?securityProfileTargetArn=#securityProfileTargetArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/things/:thingName/principals#x-amzn-principal");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amzn-principal: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/things/:thingName/principals#x-amzn-principal" {:headers {:x-amzn-principal ""}})

require "http/client"

url = "{{baseUrl}}/things/:thingName/principals#x-amzn-principal"
headers = HTTP::Headers{
  "x-amzn-principal" => ""
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/things/:thingName/principals#x-amzn-principal"),
    Headers =
    {
        { "x-amzn-principal", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/things/:thingName/principals#x-amzn-principal");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-amzn-principal", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/things/:thingName/principals#x-amzn-principal"

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("x-amzn-principal", "")

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

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

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

}

PUT /baseUrl/things/:thingName/principals HTTP/1.1
X-Amzn-Principal: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/things/:thingName/principals#x-amzn-principal")
  .setHeader("x-amzn-principal", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/things/:thingName/principals#x-amzn-principal"))
    .header("x-amzn-principal", "")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/things/:thingName/principals#x-amzn-principal")
  .put(null)
  .addHeader("x-amzn-principal", "")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/things/:thingName/principals#x-amzn-principal")
  .header("x-amzn-principal", "")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/things/:thingName/principals#x-amzn-principal');
xhr.setRequestHeader('x-amzn-principal', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/principals#x-amzn-principal',
  headers: {'x-amzn-principal': ''}
};

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

const url = '{{baseUrl}}/things/:thingName/principals#x-amzn-principal';
const options = {method: 'PUT', headers: {'x-amzn-principal': ''}};

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}}/things/:thingName/principals#x-amzn-principal',
  method: 'PUT',
  headers: {
    'x-amzn-principal': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/things/:thingName/principals#x-amzn-principal")
  .put(null)
  .addHeader("x-amzn-principal", "")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/things/:thingName/principals',
  headers: {
    'x-amzn-principal': ''
  }
};

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.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/principals#x-amzn-principal',
  headers: {'x-amzn-principal': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/things/:thingName/principals#x-amzn-principal');

req.headers({
  'x-amzn-principal': ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/principals#x-amzn-principal',
  headers: {'x-amzn-principal': ''}
};

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

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

const url = '{{baseUrl}}/things/:thingName/principals#x-amzn-principal';
const options = {method: 'PUT', headers: {'x-amzn-principal': ''}};

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

#import 

NSDictionary *headers = @{ @"x-amzn-principal": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/things/:thingName/principals#x-amzn-principal"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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}}/things/:thingName/principals#x-amzn-principal" in
let headers = Header.add (Header.init ()) "x-amzn-principal" "" in

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

 "{{baseUrl}}/things/:thingName/principals#x-amzn-principal",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-amzn-principal: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/things/:thingName/principals#x-amzn-principal', [
  'headers' => [
    'x-amzn-principal' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/things/:thingName/principals#x-amzn-principal');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-amzn-principal' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/things/:thingName/principals#x-amzn-principal');
$request->setRequestMethod('PUT');
$request->setHeaders([
  'x-amzn-principal' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amzn-principal", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/things/:thingName/principals#x-amzn-principal' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-amzn-principal", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/things/:thingName/principals#x-amzn-principal' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-amzn-principal': "" }

conn.request("PUT", "/baseUrl/things/:thingName/principals", headers=headers)

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

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

import requests

url = "{{baseUrl}}/things/:thingName/principals#x-amzn-principal"

headers = {"x-amzn-principal": ""}

response = requests.put(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/things/:thingName/principals#x-amzn-principal"

response <- VERB("PUT", url, add_headers('x-amzn-principal' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/things/:thingName/principals#x-amzn-principal")

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

request = Net::HTTP::Put.new(url)
request["x-amzn-principal"] = ''

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/things/:thingName/principals') do |req|
  req.headers['x-amzn-principal'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/things/:thingName/principals#x-amzn-principal";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amzn-principal", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

http PUT '{{baseUrl}}/things/:thingName/principals#x-amzn-principal' \
  x-amzn-principal:''

wget --quiet \
  --method PUT \
  --header 'x-amzn-principal: ' \
  --output-document \
  - '{{baseUrl}}/things/:thingName/principals#x-amzn-principal'

import Foundation

let headers = ["x-amzn-principal": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/things/:thingName/principals#x-amzn-principal")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")

require "http/client"

url = "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/audit/mitigationactions/tasks/:taskId/cancel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel'
};

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

const url = '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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}}/audit/mitigationactions/tasks/:taskId/cancel',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/mitigationactions/tasks/:taskId/cancel',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel');

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel'
};

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

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

const url = '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/audit/mitigationactions/tasks/:taskId/cancel" in

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

 "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/audit/mitigationactions/tasks/:taskId/cancel")

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

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

import requests

url = "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/audit/mitigationactions/tasks/:taskId/cancel') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http PUT {{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/mitigationactions/tasks/:taskId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/tasks/:taskId/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/audit/tasks/:taskId/cancel")

require "http/client"

url = "{{baseUrl}}/audit/tasks/:taskId/cancel"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/audit/tasks/:taskId/cancel"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/tasks/:taskId/cancel");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/tasks/:taskId/cancel"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/audit/tasks/:taskId/cancel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/audit/tasks/:taskId/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/tasks/:taskId/cancel"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/tasks/:taskId/cancel")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/audit/tasks/:taskId/cancel")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/audit/tasks/:taskId/cancel');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/audit/tasks/:taskId/cancel'};

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

const url = '{{baseUrl}}/audit/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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}}/audit/tasks/:taskId/cancel',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/tasks/:taskId/cancel")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/tasks/:taskId/cancel',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'PUT', url: '{{baseUrl}}/audit/tasks/:taskId/cancel'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/audit/tasks/:taskId/cancel');

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

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

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

const options = {method: 'PUT', url: '{{baseUrl}}/audit/tasks/:taskId/cancel'};

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

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

const url = '{{baseUrl}}/audit/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/tasks/:taskId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/audit/tasks/:taskId/cancel" in

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

 "{{baseUrl}}/audit/tasks/:taskId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/audit/tasks/:taskId/cancel');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/tasks/:taskId/cancel');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/audit/tasks/:taskId/cancel');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/tasks/:taskId/cancel' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/tasks/:taskId/cancel' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/audit/tasks/:taskId/cancel")

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

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

import requests

url = "{{baseUrl}}/audit/tasks/:taskId/cancel"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/tasks/:taskId/cancel"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/tasks/:taskId/cancel")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/audit/tasks/:taskId/cancel') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/tasks/:taskId/cancel";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http PUT {{baseUrl}}/audit/tasks/:taskId/cancel

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/audit/tasks/:taskId/cancel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/tasks/:taskId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cancel-certificate-transfer/:certificateId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/cancel-certificate-transfer/:certificateId")

require "http/client"

url = "{{baseUrl}}/cancel-certificate-transfer/:certificateId"

response = HTTP::Client.patch url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/cancel-certificate-transfer/:certificateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cancel-certificate-transfer/:certificateId");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/cancel-certificate-transfer/:certificateId"

	req, _ := http.NewRequest("PATCH", url, nil)

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

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

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

}

PATCH /baseUrl/cancel-certificate-transfer/:certificateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/cancel-certificate-transfer/:certificateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cancel-certificate-transfer/:certificateId"))
    .method("PATCH", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/cancel-certificate-transfer/:certificateId")
  .patch(null)
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/cancel-certificate-transfer/:certificateId")
  .asString();

const data = null;

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

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

xhr.open('PATCH', '{{baseUrl}}/cancel-certificate-transfer/:certificateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/cancel-certificate-transfer/:certificateId'
};

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

const url = '{{baseUrl}}/cancel-certificate-transfer/:certificateId';
const options = {method: 'PATCH'};

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}}/cancel-certificate-transfer/:certificateId',
  method: 'PATCH',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cancel-certificate-transfer/:certificateId")
  .patch(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cancel-certificate-transfer/:certificateId',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/cancel-certificate-transfer/:certificateId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/cancel-certificate-transfer/:certificateId');

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/cancel-certificate-transfer/:certificateId'
};

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

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

const url = '{{baseUrl}}/cancel-certificate-transfer/:certificateId';
const options = {method: 'PATCH'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cancel-certificate-transfer/:certificateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];

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}}/cancel-certificate-transfer/:certificateId" in

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

 "{{baseUrl}}/cancel-certificate-transfer/:certificateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/cancel-certificate-transfer/:certificateId');

echo $response->getBody();

setUrl('{{baseUrl}}/cancel-certificate-transfer/:certificateId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

setRequestUrl('{{baseUrl}}/cancel-certificate-transfer/:certificateId');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/cancel-certificate-transfer/:certificateId' -Method PATCH 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/cancel-certificate-transfer/:certificateId' -Method PATCH 

import http.client

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

conn.request("PATCH", "/baseUrl/cancel-certificate-transfer/:certificateId")

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

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

import requests

url = "{{baseUrl}}/cancel-certificate-transfer/:certificateId"

response = requests.patch(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/cancel-certificate-transfer/:certificateId"

response <- VERB("PATCH", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cancel-certificate-transfer/:certificateId")

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

request = Net::HTTP::Patch.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/cancel-certificate-transfer/:certificateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/cancel-certificate-transfer/:certificateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http PATCH {{baseUrl}}/cancel-certificate-transfer/:certificateId

wget --quiet \
  --method PATCH \
  --output-document \
  - {{baseUrl}}/cancel-certificate-transfer/:certificateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cancel-certificate-transfer/:certificateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")

require "http/client"

url = "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"

	req, _ := http.NewRequest("PUT", url, nil)

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

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

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

}

PUT /baseUrl/detect/mitigationactions/tasks/:taskId/cancel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel'
};

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

const url = '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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}}/detect/mitigationactions/tasks/:taskId/cancel',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/detect/mitigationactions/tasks/:taskId/cancel',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel');

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel'
};

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

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

const url = '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel';
const options = {method: 'PUT'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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}}/detect/mitigationactions/tasks/:taskId/cancel" in

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

 "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel');

echo $response->getBody();

setUrl('{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel' -Method PUT 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel' -Method PUT 

import http.client

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

conn.request("PUT", "/baseUrl/detect/mitigationactions/tasks/:taskId/cancel")

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

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

import requests

url = "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")

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

request = Net::HTTP::Put.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/detect/mitigationactions/tasks/:taskId/cancel') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http PUT {{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/detect/mitigationactions/tasks/:taskId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/jobs/:jobId/cancel");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/jobs/:jobId/cancel" {:content-type :json
                                                              :form-params {:reasonCode ""
                                                                            :comment ""}})

require "http/client"

url = "{{baseUrl}}/jobs/:jobId/cancel"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/jobs/:jobId/cancel"),
    Content = new StringContent("{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\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}}/jobs/:jobId/cancel");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/jobs/:jobId/cancel"

	payload := strings.NewReader("{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}")

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

	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))

}

PUT /baseUrl/jobs/:jobId/cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "reasonCode": "",
  "comment": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/jobs/:jobId/cancel")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs/:jobId/cancel"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\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  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/jobs/:jobId/cancel")
  .header("content-type", "application/json")
  .body("{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  reasonCode: '',
  comment: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/jobs/:jobId/cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  data: {reasonCode: '', comment: ''}
};

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

const url = '{{baseUrl}}/jobs/:jobId/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reasonCode":"","comment":""}'
};

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}}/jobs/:jobId/cancel',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "reasonCode": "",\n  "comment": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jobs/:jobId/cancel',
  headers: {
    '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({reasonCode: '', comment: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  body: {reasonCode: '', comment: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/jobs/:jobId/cancel');

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

req.type('json');
req.send({
  reasonCode: '',
  comment: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  data: {reasonCode: '', comment: ''}
};

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

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

const url = '{{baseUrl}}/jobs/:jobId/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"reasonCode":"","comment":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"reasonCode": @"",
                              @"comment": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/jobs/:jobId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/jobs/:jobId/cancel" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}" in

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

 "{{baseUrl}}/jobs/:jobId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'reasonCode' => '',
    'comment' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/jobs/:jobId/cancel', [
  'body' => '{
  "reasonCode": "",
  "comment": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/jobs/:jobId/cancel');
$request->setMethod(HTTP_METH_PUT);

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

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

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

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

append(json_encode([
  'reasonCode' => '',
  'comment' => ''
]));
$request->setRequestUrl('{{baseUrl}}/jobs/:jobId/cancel');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs/:jobId/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reasonCode": "",
  "comment": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs/:jobId/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "reasonCode": "",
  "comment": ""
}'

import http.client

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

payload = "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/jobs/:jobId/cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/jobs/:jobId/cancel"

payload = {
    "reasonCode": "",
    "comment": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/jobs/:jobId/cancel"

payload <- "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jobs/:jobId/cancel")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\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.put('/baseUrl/jobs/:jobId/cancel') do |req|
  req.body = "{\n  \"reasonCode\": \"\",\n  \"comment\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jobs/:jobId/cancel";

    let payload = json!({
        "reasonCode": "",
        "comment": ""
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "reasonCode": "",
  "comment": ""
}' |  \
  http PUT {{baseUrl}}/jobs/:jobId/cancel \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "reasonCode": "",\n  "comment": ""\n}' \
  --output-document \
  - {{baseUrl}}/jobs/:jobId/cancel

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "reasonCode": "",
  "comment": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jobs/:jobId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel" {:content-type :json
                                                                                :form-params {:expectedVersion 0
                                                                                              :statusDetails {}}})

require "http/client"

url = "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"),
    Content = new StringContent("{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\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}}/things/:thingName/jobs/:jobId/cancel");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"

	payload := strings.NewReader("{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}")

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

	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))

}

PUT /baseUrl/things/:thingName/jobs/:jobId/cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "expectedVersion": 0,
  "statusDetails": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\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  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")
  .header("content-type", "application/json")
  .body("{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}")
  .asString();

const data = JSON.stringify({
  expectedVersion: 0,
  statusDetails: {}
});

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

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

xhr.open('PUT', '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  data: {expectedVersion: 0, statusDetails: {}}
};

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

const url = '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expectedVersion":0,"statusDetails":{}}'
};

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}}/things/:thingName/jobs/:jobId/cancel',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "expectedVersion": 0,\n  "statusDetails": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/things/:thingName/jobs/:jobId/cancel',
  headers: {
    '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({expectedVersion: 0, statusDetails: {}}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  body: {expectedVersion: 0, statusDetails: {}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel');

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

req.type('json');
req.send({
  expectedVersion: 0,
  statusDetails: {}
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel',
  headers: {'content-type': 'application/json'},
  data: {expectedVersion: 0, statusDetails: {}}
};

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

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

const url = '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"expectedVersion":0,"statusDetails":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"expectedVersion": @0,
                              @"statusDetails": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/things/:thingName/jobs/:jobId/cancel" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}" in

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

 "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'expectedVersion' => 0,
    'statusDetails' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel', [
  'body' => '{
  "expectedVersion": 0,
  "statusDetails": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/things/:thingName/jobs/:jobId/cancel');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'expectedVersion' => 0,
  'statusDetails' => [
    
  ]
]));

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

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

append(json_encode([
  'expectedVersion' => 0,
  'statusDetails' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/things/:thingName/jobs/:jobId/cancel');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expectedVersion": 0,
  "statusDetails": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/things/:thingName/jobs/:jobId/cancel' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "expectedVersion": 0,
  "statusDetails": {}
}'

import http.client

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

payload = "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/things/:thingName/jobs/:jobId/cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"

payload = {
    "expectedVersion": 0,
    "statusDetails": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel"

payload <- "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\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.put('/baseUrl/things/:thingName/jobs/:jobId/cancel') do |req|
  req.body = "{\n  \"expectedVersion\": 0,\n  \"statusDetails\": {}\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel";

    let payload = json!({
        "expectedVersion": 0,
        "statusDetails": json!({})
    });

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

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "expectedVersion": 0,
  "statusDetails": {}
}' |  \
  http PUT {{baseUrl}}/things/:thingName/jobs/:jobId/cancel \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "expectedVersion": 0,\n  "statusDetails": {}\n}' \
  --output-document \
  - {{baseUrl}}/things/:thingName/jobs/:jobId/cancel

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "expectedVersion": 0,
  "statusDetails": []
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/things/:thingName/jobs/:jobId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/default-authorizer");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/default-authorizer")

require "http/client"

url = "{{baseUrl}}/default-authorizer"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/default-authorizer"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/default-authorizer");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/default-authorizer"

	req, _ := http.NewRequest("DELETE", url, nil)

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

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

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

}

DELETE /baseUrl/default-authorizer HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/default-authorizer")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/default-authorizer"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/default-authorizer")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/default-authorizer")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/default-authorizer');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/default-authorizer'};

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

const url = '{{baseUrl}}/default-authorizer';
const options = {method: 'DELETE'};

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}}/default-authorizer',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/default-authorizer")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/default-authorizer',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/default-authorizer'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/default-authorizer');

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

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

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

const options = {method: 'DELETE', url: '{{baseUrl}}/default-authorizer'};

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

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

const url = '{{baseUrl}}/default-authorizer';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/default-authorizer"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/default-authorizer" in

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

 "{{baseUrl}}/default-authorizer",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/default-authorizer');

echo $response->getBody();

setUrl('{{baseUrl}}/default-authorizer');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/default-authorizer');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/default-authorizer' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/default-authorizer' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/default-authorizer")

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

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

import requests

url = "{{baseUrl}}/default-authorizer"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/default-authorizer"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/default-authorizer")

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

request = Net::HTTP::Delete.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/default-authorizer') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/default-authorizer";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

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

    dbg!(results);
}

http DELETE {{baseUrl}}/default-authorizer

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/default-authorizer

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/default-authorizer")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/confirmdestination/:confirmationToken");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/confirmdestination/:confirmationToken")

require "http/client"

url = "{{baseUrl}}/confirmdestination/:confirmationToken"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/confirmdestination/:confirmationToken"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/confirmdestination/:confirmationToken");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/confirmdestination/:confirmationToken"

	req, _ := http.NewRequest("GET", url, nil)

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

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

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

}

GET /baseUrl/confirmdestination/:confirmationToken HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/confirmdestination/:confirmationToken")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/confirmdestination/:confirmationToken"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/confirmdestination/:confirmationToken")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/confirmdestination/:confirmationToken")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/confirmdestination/:confirmationToken');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/confirmdestination/:confirmationToken'
};

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

const url = '{{baseUrl}}/confirmdestination/:confirmationToken';
const options = {method: 'GET'};

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}}/confirmdestination/:confirmationToken',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/confirmdestination/:confirmationToken")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/confirmdestination/:confirmationToken',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/confirmdestination/:confirmationToken'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/confirmdestination/:confirmationToken');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/confirmdestination/:confirmationToken'
};

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

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

const url = '{{baseUrl}}/confirmdestination/:confirmationToken';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/confirmdestination/:confirmationToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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}}/confirmdestination/:confirmationToken" in

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

 "{{baseUrl}}/confirmdestination/:confirmationToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/confirmdestination/:confirmationToken');

echo $response->getBody();

setUrl('{{baseUrl}}/confirmdestination/:confirmationToken');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/confirmdestination/:confirmationToken');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/confirmdestination/:confirmationToken' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/confirmdestination/:confirmationToken' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/confirmdestination/:confirmationToken")

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

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

import requests

url = "{{baseUrl}}/confirmdestination/:confirmationToken"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/confirmdestination/:confirmationToken"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/confirmdestination/:confirmationToken")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/confirmdestination/:confirmationToken') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/confirmdestination/:confirmationToken";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/confirmdestination/:confirmationToken

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/confirmdestination/:confirmationToken

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/confirmdestination/:confirmationToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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}}/audit/suppressions/create");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/audit/suppressions/create" {:content-type :json
                                                                      :form-params {:checkName ""
                                                                                    :resourceIdentifier {:deviceCertificateId ""
                                                                                                         :caCertificateId ""
                                                                                                         :cognitoIdentityPoolId ""
                                                                                                         :clientId ""
                                                                                                         :policyVersionIdentifier ""
                                                                                                         :account ""
                                                                                                         :iamRoleArn ""
                                                                                                         :roleAliasArn ""
                                                                                                         :issuerCertificateIdentifier ""
                                                                                                         :deviceCertificateArn ""}
                                                                                    :expirationDate ""
                                                                                    :suppressIndefinitely false
                                                                                    :description ""
                                                                                    :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/audit/suppressions/create"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/audit/suppressions/create"),
    Content = new StringContent("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/suppressions/create");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/audit/suppressions/create"

	payload := strings.NewReader("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}")

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

	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/audit/suppressions/create HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 439

{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  },
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/suppressions/create")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/suppressions/create"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/suppressions/create")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/audit/suppressions/create")
  .header("content-type", "application/json")
  .body("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  },
  expirationDate: '',
  suppressIndefinitely: false,
  description: '',
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/audit/suppressions/create');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/suppressions/create',
  headers: {'content-type': 'application/json'},
  data: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    },
    expirationDate: '',
    suppressIndefinitely: false,
    description: '',
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/audit/suppressions/create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checkName":"","resourceIdentifier":{"deviceCertificateId":"","caCertificateId":"","cognitoIdentityPoolId":"","clientId":"","policyVersionIdentifier":"","account":"","iamRoleArn":"","roleAliasArn":"","issuerCertificateIdentifier":"","deviceCertificateArn":""},"expirationDate":"","suppressIndefinitely":false,"description":"","clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/audit/suppressions/create',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checkName": "",\n  "resourceIdentifier": {\n    "deviceCertificateId": "",\n    "caCertificateId": "",\n    "cognitoIdentityPoolId": "",\n    "clientId": "",\n    "policyVersionIdentifier": "",\n    "account": "",\n    "iamRoleArn": "",\n    "roleAliasArn": "",\n    "issuerCertificateIdentifier": "",\n    "deviceCertificateArn": ""\n  },\n  "expirationDate": "",\n  "suppressIndefinitely": false,\n  "description": "",\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/suppressions/create")
  .post(body)
  .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/audit/suppressions/create',
  headers: {
    '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({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  },
  expirationDate: '',
  suppressIndefinitely: false,
  description: '',
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/suppressions/create',
  headers: {'content-type': 'application/json'},
  body: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    },
    expirationDate: '',
    suppressIndefinitely: false,
    description: '',
    clientRequestToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/audit/suppressions/create');

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

req.type('json');
req.send({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  },
  expirationDate: '',
  suppressIndefinitely: false,
  description: '',
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/suppressions/create',
  headers: {'content-type': 'application/json'},
  data: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    },
    expirationDate: '',
    suppressIndefinitely: false,
    description: '',
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/audit/suppressions/create';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checkName":"","resourceIdentifier":{"deviceCertificateId":"","caCertificateId":"","cognitoIdentityPoolId":"","clientId":"","policyVersionIdentifier":"","account":"","iamRoleArn":"","roleAliasArn":"","issuerCertificateIdentifier":"","deviceCertificateArn":""},"expirationDate":"","suppressIndefinitely":false,"description":"","clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"checkName": @"",
                              @"resourceIdentifier": @{ @"deviceCertificateId": @"", @"caCertificateId": @"", @"cognitoIdentityPoolId": @"", @"clientId": @"", @"policyVersionIdentifier": @"", @"account": @"", @"iamRoleArn": @"", @"roleAliasArn": @"", @"issuerCertificateIdentifier": @"", @"deviceCertificateArn": @"" },
                              @"expirationDate": @"",
                              @"suppressIndefinitely": @NO,
                              @"description": @"",
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/suppressions/create"]
                                                       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}}/audit/suppressions/create" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/audit/suppressions/create",
  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([
    'checkName' => '',
    'resourceIdentifier' => [
        'deviceCertificateId' => '',
        'caCertificateId' => '',
        'cognitoIdentityPoolId' => '',
        'clientId' => '',
        'policyVersionIdentifier' => '',
        'account' => '',
        'iamRoleArn' => '',
        'roleAliasArn' => '',
        'issuerCertificateIdentifier' => '',
        'deviceCertificateArn' => ''
    ],
    'expirationDate' => '',
    'suppressIndefinitely' => null,
    'description' => '',
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/audit/suppressions/create', [
  'body' => '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  },
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/suppressions/create');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'checkName' => '',
  'resourceIdentifier' => [
    'deviceCertificateId' => '',
    'caCertificateId' => '',
    'cognitoIdentityPoolId' => '',
    'clientId' => '',
    'policyVersionIdentifier' => '',
    'account' => '',
    'iamRoleArn' => '',
    'roleAliasArn' => '',
    'issuerCertificateIdentifier' => '',
    'deviceCertificateArn' => ''
  ],
  'expirationDate' => '',
  'suppressIndefinitely' => null,
  'description' => '',
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'checkName' => '',
  'resourceIdentifier' => [
    'deviceCertificateId' => '',
    'caCertificateId' => '',
    'cognitoIdentityPoolId' => '',
    'clientId' => '',
    'policyVersionIdentifier' => '',
    'account' => '',
    'iamRoleArn' => '',
    'roleAliasArn' => '',
    'issuerCertificateIdentifier' => '',
    'deviceCertificateArn' => ''
  ],
  'expirationDate' => '',
  'suppressIndefinitely' => null,
  'description' => '',
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/audit/suppressions/create');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/suppressions/create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  },
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/suppressions/create' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  },
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/audit/suppressions/create"

payload = {
    "checkName": "",
    "resourceIdentifier": {
        "deviceCertificateId": "",
        "caCertificateId": "",
        "cognitoIdentityPoolId": "",
        "clientId": "",
        "policyVersionIdentifier": "",
        "account": "",
        "iamRoleArn": "",
        "roleAliasArn": "",
        "issuerCertificateIdentifier": "",
        "deviceCertificateArn": ""
    },
    "expirationDate": "",
    "suppressIndefinitely": False,
    "description": "",
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/suppressions/create"

payload <- "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/suppressions/create")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/audit/suppressions/create') do |req|
  req.body = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  },\n  \"expirationDate\": \"\",\n  \"suppressIndefinitely\": false,\n  \"description\": \"\",\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/suppressions/create";

    let payload = json!({
        "checkName": "",
        "resourceIdentifier": json!({
            "deviceCertificateId": "",
            "caCertificateId": "",
            "cognitoIdentityPoolId": "",
            "clientId": "",
            "policyVersionIdentifier": "",
            "account": "",
            "iamRoleArn": "",
            "roleAliasArn": "",
            "issuerCertificateIdentifier": "",
            "deviceCertificateArn": ""
        }),
        "expirationDate": "",
        "suppressIndefinitely": false,
        "description": "",
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  },
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/audit/suppressions/create \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "checkName": "",\n  "resourceIdentifier": {\n    "deviceCertificateId": "",\n    "caCertificateId": "",\n    "cognitoIdentityPoolId": "",\n    "clientId": "",\n    "policyVersionIdentifier": "",\n    "account": "",\n    "iamRoleArn": "",\n    "roleAliasArn": "",\n    "issuerCertificateIdentifier": "",\n    "deviceCertificateArn": ""\n  },\n  "expirationDate": "",\n  "suppressIndefinitely": false,\n  "description": "",\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/audit/suppressions/create

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "checkName": "",
  "resourceIdentifier": [
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  ],
  "expirationDate": "",
  "suppressIndefinitely": false,
  "description": "",
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/suppressions/create")! 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}}/authorizer/:authorizerName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/authorizer/:authorizerName" {:content-type :json
                                                                       :form-params {:authorizerFunctionArn ""
                                                                                     :tokenKeyName ""
                                                                                     :tokenSigningPublicKeys {}
                                                                                     :status ""
                                                                                     :tags [{:Key ""
                                                                                             :Value ""}]
                                                                                     :signingDisabled false
                                                                                     :enableCachingForHttp false}})

require "http/client"

url = "{{baseUrl}}/authorizer/:authorizerName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\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}}/authorizer/:authorizerName"),
    Content = new StringContent("{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\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}}/authorizer/:authorizerName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/authorizer/:authorizerName"

	payload := strings.NewReader("{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}")

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

	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/authorizer/:authorizerName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 228

{
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": {},
  "status": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/authorizer/:authorizerName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authorizer/:authorizerName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\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  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/authorizer/:authorizerName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/authorizer/:authorizerName")
  .header("content-type", "application/json")
  .body("{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}")
  .asString();

const data = JSON.stringify({
  authorizerFunctionArn: '',
  tokenKeyName: '',
  tokenSigningPublicKeys: {},
  status: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  signingDisabled: false,
  enableCachingForHttp: false
});

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

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

xhr.open('POST', '{{baseUrl}}/authorizer/:authorizerName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authorizer/:authorizerName',
  headers: {'content-type': 'application/json'},
  data: {
    authorizerFunctionArn: '',
    tokenKeyName: '',
    tokenSigningPublicKeys: {},
    status: '',
    tags: [{Key: '', Value: ''}],
    signingDisabled: false,
    enableCachingForHttp: false
  }
};

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

const url = '{{baseUrl}}/authorizer/:authorizerName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizerFunctionArn":"","tokenKeyName":"","tokenSigningPublicKeys":{},"status":"","tags":[{"Key":"","Value":""}],"signingDisabled":false,"enableCachingForHttp":false}'
};

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}}/authorizer/:authorizerName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "authorizerFunctionArn": "",\n  "tokenKeyName": "",\n  "tokenSigningPublicKeys": {},\n  "status": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "signingDisabled": false,\n  "enableCachingForHttp": false\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/authorizer/:authorizerName")
  .post(body)
  .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/authorizer/:authorizerName',
  headers: {
    '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({
  authorizerFunctionArn: '',
  tokenKeyName: '',
  tokenSigningPublicKeys: {},
  status: '',
  tags: [{Key: '', Value: ''}],
  signingDisabled: false,
  enableCachingForHttp: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/authorizer/:authorizerName',
  headers: {'content-type': 'application/json'},
  body: {
    authorizerFunctionArn: '',
    tokenKeyName: '',
    tokenSigningPublicKeys: {},
    status: '',
    tags: [{Key: '', Value: ''}],
    signingDisabled: false,
    enableCachingForHttp: false
  },
  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}}/authorizer/:authorizerName');

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

req.type('json');
req.send({
  authorizerFunctionArn: '',
  tokenKeyName: '',
  tokenSigningPublicKeys: {},
  status: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  signingDisabled: false,
  enableCachingForHttp: false
});

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}}/authorizer/:authorizerName',
  headers: {'content-type': 'application/json'},
  data: {
    authorizerFunctionArn: '',
    tokenKeyName: '',
    tokenSigningPublicKeys: {},
    status: '',
    tags: [{Key: '', Value: ''}],
    signingDisabled: false,
    enableCachingForHttp: false
  }
};

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

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

const url = '{{baseUrl}}/authorizer/:authorizerName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"authorizerFunctionArn":"","tokenKeyName":"","tokenSigningPublicKeys":{},"status":"","tags":[{"Key":"","Value":""}],"signingDisabled":false,"enableCachingForHttp":false}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"authorizerFunctionArn": @"",
                              @"tokenKeyName": @"",
                              @"tokenSigningPublicKeys": @{  },
                              @"status": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"signingDisabled": @NO,
                              @"enableCachingForHttp": @NO };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authorizer/:authorizerName"]
                                                       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}}/authorizer/:authorizerName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}" in

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

 "{{baseUrl}}/authorizer/:authorizerName",
  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([
    'authorizerFunctionArn' => '',
    'tokenKeyName' => '',
    'tokenSigningPublicKeys' => [
        
    ],
    'status' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'signingDisabled' => null,
    'enableCachingForHttp' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/authorizer/:authorizerName', [
  'body' => '{
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": {},
  "status": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/authorizer/:authorizerName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'authorizerFunctionArn' => '',
  'tokenKeyName' => '',
  'tokenSigningPublicKeys' => [
    
  ],
  'status' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'signingDisabled' => null,
  'enableCachingForHttp' => null
]));

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

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

append(json_encode([
  'authorizerFunctionArn' => '',
  'tokenKeyName' => '',
  'tokenSigningPublicKeys' => [
    
  ],
  'status' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'signingDisabled' => null,
  'enableCachingForHttp' => null
]));
$request->setRequestUrl('{{baseUrl}}/authorizer/:authorizerName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/authorizer/:authorizerName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": {},
  "status": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/authorizer/:authorizerName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": {},
  "status": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
}'

import http.client

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

payload = "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/authorizer/:authorizerName"

payload = {
    "authorizerFunctionArn": "",
    "tokenKeyName": "",
    "tokenSigningPublicKeys": {},
    "status": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "signingDisabled": False,
    "enableCachingForHttp": False
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/authorizer/:authorizerName"

payload <- "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authorizer/:authorizerName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\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/authorizer/:authorizerName') do |req|
  req.body = "{\n  \"authorizerFunctionArn\": \"\",\n  \"tokenKeyName\": \"\",\n  \"tokenSigningPublicKeys\": {},\n  \"status\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"signingDisabled\": false,\n  \"enableCachingForHttp\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authorizer/:authorizerName";

    let payload = json!({
        "authorizerFunctionArn": "",
        "tokenKeyName": "",
        "tokenSigningPublicKeys": json!({}),
        "status": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "signingDisabled": false,
        "enableCachingForHttp": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": {},
  "status": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
}' |  \
  http POST {{baseUrl}}/authorizer/:authorizerName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "authorizerFunctionArn": "",\n  "tokenKeyName": "",\n  "tokenSigningPublicKeys": {},\n  "status": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "signingDisabled": false,\n  "enableCachingForHttp": false\n}' \
  --output-document \
  - {{baseUrl}}/authorizer/:authorizerName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "authorizerFunctionArn": "",
  "tokenKeyName": "",
  "tokenSigningPublicKeys": [],
  "status": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "signingDisabled": false,
  "enableCachingForHttp": false
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authorizer/:authorizerName")! 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}}/billing-groups/:billingGroupName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/billing-groups/:billingGroupName" {:content-type :json
                                                                             :form-params {:billingGroupProperties {:billingGroupDescription ""}
                                                                                           :tags [{:Key ""
                                                                                                   :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/billing-groups/:billingGroupName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/billing-groups/:billingGroupName"),
    Content = new StringContent("{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/billing-groups/:billingGroupName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/billing-groups/:billingGroupName"

	payload := strings.NewReader("{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/billing-groups/:billingGroupName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "billingGroupProperties": {
    "billingGroupDescription": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/billing-groups/:billingGroupName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing-groups/:billingGroupName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/billing-groups/:billingGroupName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/billing-groups/:billingGroupName")
  .header("content-type", "application/json")
  .body("{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  billingGroupProperties: {
    billingGroupDescription: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/billing-groups/:billingGroupName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing-groups/:billingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    billingGroupProperties: {billingGroupDescription: ''},
    tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/billing-groups/:billingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"billingGroupProperties":{"billingGroupDescription":""},"tags":[{"Key":"","Value":""}]}'
};

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}}/billing-groups/:billingGroupName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "billingGroupProperties": {\n    "billingGroupDescription": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/billing-groups/:billingGroupName")
  .post(body)
  .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/billing-groups/:billingGroupName',
  headers: {
    '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({
  billingGroupProperties: {billingGroupDescription: ''},
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/billing-groups/:billingGroupName',
  headers: {'content-type': 'application/json'},
  body: {
    billingGroupProperties: {billingGroupDescription: ''},
    tags: [{Key: '', Value: ''}]
  },
  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}}/billing-groups/:billingGroupName');

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

req.type('json');
req.send({
  billingGroupProperties: {
    billingGroupDescription: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/billing-groups/:billingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    billingGroupProperties: {billingGroupDescription: ''},
    tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/billing-groups/:billingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"billingGroupProperties":{"billingGroupDescription":""},"tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"billingGroupProperties": @{ @"billingGroupDescription": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing-groups/:billingGroupName"]
                                                       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}}/billing-groups/:billingGroupName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/billing-groups/:billingGroupName",
  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([
    'billingGroupProperties' => [
        'billingGroupDescription' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/billing-groups/:billingGroupName', [
  'body' => '{
  "billingGroupProperties": {
    "billingGroupDescription": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/billing-groups/:billingGroupName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'billingGroupProperties' => [
    'billingGroupDescription' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'billingGroupProperties' => [
    'billingGroupDescription' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/billing-groups/:billingGroupName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing-groups/:billingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "billingGroupProperties": {
    "billingGroupDescription": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing-groups/:billingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "billingGroupProperties": {
    "billingGroupDescription": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/billing-groups/:billingGroupName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/billing-groups/:billingGroupName"

payload = {
    "billingGroupProperties": { "billingGroupDescription": "" },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing-groups/:billingGroupName"

payload <- "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing-groups/:billingGroupName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/billing-groups/:billingGroupName') do |req|
  req.body = "{\n  \"billingGroupProperties\": {\n    \"billingGroupDescription\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/billing-groups/:billingGroupName";

    let payload = json!({
        "billingGroupProperties": json!({"billingGroupDescription": ""}),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "billingGroupProperties": {
    "billingGroupDescription": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/billing-groups/:billingGroupName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "billingGroupProperties": {\n    "billingGroupDescription": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/billing-groups/:billingGroupName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "billingGroupProperties": ["billingGroupDescription": ""],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/billing-groups/:billingGroupName")! 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}}/certificates");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/certificates" {:content-type :json
                                                         :form-params {:certificateSigningRequest ""}})

require "http/client"

url = "{{baseUrl}}/certificates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"certificateSigningRequest\": \"\"\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}}/certificates"),
    Content = new StringContent("{\n  \"certificateSigningRequest\": \"\"\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}}/certificates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"certificateSigningRequest\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/certificates"

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

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

	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/certificates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "certificateSigningRequest": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/certificates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"certificateSigningRequest\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/certificates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"certificateSigningRequest\": \"\"\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  \"certificateSigningRequest\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/certificates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/certificates")
  .header("content-type", "application/json")
  .body("{\n  \"certificateSigningRequest\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/certificates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/certificates',
  headers: {'content-type': 'application/json'},
  data: {certificateSigningRequest: ''}
};

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

const url = '{{baseUrl}}/certificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"certificateSigningRequest":""}'
};

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}}/certificates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "certificateSigningRequest": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"certificateSigningRequest\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/certificates")
  .post(body)
  .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/certificates',
  headers: {
    '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({certificateSigningRequest: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/certificates',
  headers: {'content-type': 'application/json'},
  body: {certificateSigningRequest: ''},
  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}}/certificates');

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

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

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}}/certificates',
  headers: {'content-type': 'application/json'},
  data: {certificateSigningRequest: ''}
};

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

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

const url = '{{baseUrl}}/certificates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"certificateSigningRequest":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"certificateSigningRequest": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/certificates"]
                                                       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}}/certificates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"certificateSigningRequest\": \"\"\n}" in

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

 "{{baseUrl}}/certificates",
  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([
    'certificateSigningRequest' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/certificates', [
  'body' => '{
  "certificateSigningRequest": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/certificates');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'certificateSigningRequest' => ''
]));
$request->setRequestUrl('{{baseUrl}}/certificates');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificateSigningRequest": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "certificateSigningRequest": ""
}'

import http.client

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

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

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/certificates"

payload = { "certificateSigningRequest": "" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/certificates"

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

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/certificates")

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/certificates";

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

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "certificateSigningRequest": ""
}' |  \
  http POST {{baseUrl}}/certificates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "certificateSigningRequest": ""\n}' \
  --output-document \
  - {{baseUrl}}/certificates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["certificateSigningRequest": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates")! 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}}/custom-metric/:metricName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/custom-metric/:metricName" {:content-type :json
                                                                      :form-params {:displayName ""
                                                                                    :metricType ""
                                                                                    :tags [{:Key ""
                                                                                            :Value ""}]
                                                                                    :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/custom-metric/:metricName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/custom-metric/:metricName"),
    Content = new StringContent("{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/custom-metric/:metricName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/custom-metric/:metricName"

	payload := strings.NewReader("{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")

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

	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/custom-metric/:metricName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "displayName": "",
  "metricType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/custom-metric/:metricName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/custom-metric/:metricName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/custom-metric/:metricName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/custom-metric/:metricName")
  .header("content-type", "application/json")
  .body("{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  displayName: '',
  metricType: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/custom-metric/:metricName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/custom-metric/:metricName',
  headers: {'content-type': 'application/json'},
  data: {
    displayName: '',
    metricType: '',
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/custom-metric/:metricName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","metricType":"","tags":[{"Key":"","Value":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/custom-metric/:metricName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "displayName": "",\n  "metricType": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/custom-metric/:metricName")
  .post(body)
  .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/custom-metric/:metricName',
  headers: {
    '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({
  displayName: '',
  metricType: '',
  tags: [{Key: '', Value: ''}],
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/custom-metric/:metricName',
  headers: {'content-type': 'application/json'},
  body: {
    displayName: '',
    metricType: '',
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/custom-metric/:metricName');

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

req.type('json');
req.send({
  displayName: '',
  metricType: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/custom-metric/:metricName',
  headers: {'content-type': 'application/json'},
  data: {
    displayName: '',
    metricType: '',
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/custom-metric/:metricName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"displayName":"","metricType":"","tags":[{"Key":"","Value":""}],"clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"displayName": @"",
                              @"metricType": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/custom-metric/:metricName"]
                                                       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}}/custom-metric/:metricName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/custom-metric/:metricName",
  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([
    'displayName' => '',
    'metricType' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/custom-metric/:metricName', [
  'body' => '{
  "displayName": "",
  "metricType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/custom-metric/:metricName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'displayName' => '',
  'metricType' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'displayName' => '',
  'metricType' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/custom-metric/:metricName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/custom-metric/:metricName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "metricType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/custom-metric/:metricName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "displayName": "",
  "metricType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/custom-metric/:metricName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/custom-metric/:metricName"

payload = {
    "displayName": "",
    "metricType": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/custom-metric/:metricName"

payload <- "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/custom-metric/:metricName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/custom-metric/:metricName') do |req|
  req.body = "{\n  \"displayName\": \"\",\n  \"metricType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/custom-metric/:metricName";

    let payload = json!({
        "displayName": "",
        "metricType": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "displayName": "",
  "metricType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/custom-metric/:metricName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "displayName": "",\n  "metricType": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/custom-metric/:metricName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "displayName": "",
  "metricType": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/custom-metric/:metricName")! 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}}/dimensions/:name");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/dimensions/:name" {:content-type :json
                                                             :form-params {:type ""
                                                                           :stringValues []
                                                                           :tags [{:Key ""
                                                                                   :Value ""}]
                                                                           :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/dimensions/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/dimensions/:name"),
    Content = new StringContent("{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dimensions/:name");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/dimensions/:name"

	payload := strings.NewReader("{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")

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

	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/dimensions/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "type": "",
  "stringValues": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dimensions/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dimensions/:name"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dimensions/:name")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/dimensions/:name")
  .header("content-type", "application/json")
  .body("{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  type: '',
  stringValues: [],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/dimensions/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dimensions/:name',
  headers: {'content-type': 'application/json'},
  data: {
    type: '',
    stringValues: [],
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/dimensions/:name';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"type":"","stringValues":[],"tags":[{"Key":"","Value":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dimensions/:name',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "type": "",\n  "stringValues": [],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dimensions/:name")
  .post(body)
  .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/dimensions/:name',
  headers: {
    '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({
  type: '',
  stringValues: [],
  tags: [{Key: '', Value: ''}],
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dimensions/:name',
  headers: {'content-type': 'application/json'},
  body: {
    type: '',
    stringValues: [],
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/dimensions/:name');

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

req.type('json');
req.send({
  type: '',
  stringValues: [],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dimensions/:name',
  headers: {'content-type': 'application/json'},
  data: {
    type: '',
    stringValues: [],
    tags: [{Key: '', Value: ''}],
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/dimensions/:name';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"type":"","stringValues":[],"tags":[{"Key":"","Value":""}],"clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"type": @"",
                              @"stringValues": @[  ],
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dimensions/:name"]
                                                       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}}/dimensions/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/dimensions/:name",
  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([
    'type' => '',
    'stringValues' => [
        
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/dimensions/:name', [
  'body' => '{
  "type": "",
  "stringValues": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/dimensions/:name');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'type' => '',
  'stringValues' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'type' => '',
  'stringValues' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/dimensions/:name');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dimensions/:name' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "type": "",
  "stringValues": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dimensions/:name' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "type": "",
  "stringValues": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/dimensions/:name"

payload = {
    "type": "",
    "stringValues": [],
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/dimensions/:name"

payload <- "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dimensions/:name")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/dimensions/:name') do |req|
  req.body = "{\n  \"type\": \"\",\n  \"stringValues\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dimensions/:name";

    let payload = json!({
        "type": "",
        "stringValues": (),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "type": "",
  "stringValues": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/dimensions/:name \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "type": "",\n  "stringValues": [],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/dimensions/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "type": "",
  "stringValues": [],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dimensions/:name")! 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}}/domainConfigurations/:domainConfigurationName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/domainConfigurations/:domainConfigurationName" {:content-type :json
                                                                                          :form-params {:domainName ""
                                                                                                        :serverCertificateArns []
                                                                                                        :validationCertificateArn ""
                                                                                                        :authorizerConfig {:defaultAuthorizerName ""
                                                                                                                           :allowAuthorizerOverride ""}
                                                                                                        :serviceType ""
                                                                                                        :tags [{:Key ""
                                                                                                                :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/domainConfigurations/:domainConfigurationName"),
    Content = new StringContent("{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/domainConfigurations/:domainConfigurationName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

	payload := strings.NewReader("{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/domainConfigurations/:domainConfigurationName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 268

{
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": {
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  },
  "serviceType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainConfigurations/:domainConfigurationName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .header("content-type", "application/json")
  .body("{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  domainName: '',
  serverCertificateArns: [],
  validationCertificateArn: '',
  authorizerConfig: {
    defaultAuthorizerName: '',
    allowAuthorizerOverride: ''
  },
  serviceType: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/domainConfigurations/:domainConfigurationName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainConfigurations/:domainConfigurationName',
  headers: {'content-type': 'application/json'},
  data: {
    domainName: '',
    serverCertificateArns: [],
    validationCertificateArn: '',
    authorizerConfig: {defaultAuthorizerName: '', allowAuthorizerOverride: ''},
    serviceType: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/domainConfigurations/:domainConfigurationName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","serverCertificateArns":[],"validationCertificateArn":"","authorizerConfig":{"defaultAuthorizerName":"","allowAuthorizerOverride":""},"serviceType":"","tags":[{"Key":"","Value":""}]}'
};

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}}/domainConfigurations/:domainConfigurationName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domainName": "",\n  "serverCertificateArns": [],\n  "validationCertificateArn": "",\n  "authorizerConfig": {\n    "defaultAuthorizerName": "",\n    "allowAuthorizerOverride": ""\n  },\n  "serviceType": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .post(body)
  .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/domainConfigurations/:domainConfigurationName',
  headers: {
    '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({
  domainName: '',
  serverCertificateArns: [],
  validationCertificateArn: '',
  authorizerConfig: {defaultAuthorizerName: '', allowAuthorizerOverride: ''},
  serviceType: '',
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/domainConfigurations/:domainConfigurationName',
  headers: {'content-type': 'application/json'},
  body: {
    domainName: '',
    serverCertificateArns: [],
    validationCertificateArn: '',
    authorizerConfig: {defaultAuthorizerName: '', allowAuthorizerOverride: ''},
    serviceType: '',
    tags: [{Key: '', Value: ''}]
  },
  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}}/domainConfigurations/:domainConfigurationName');

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

req.type('json');
req.send({
  domainName: '',
  serverCertificateArns: [],
  validationCertificateArn: '',
  authorizerConfig: {
    defaultAuthorizerName: '',
    allowAuthorizerOverride: ''
  },
  serviceType: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/domainConfigurations/:domainConfigurationName',
  headers: {'content-type': 'application/json'},
  data: {
    domainName: '',
    serverCertificateArns: [],
    validationCertificateArn: '',
    authorizerConfig: {defaultAuthorizerName: '', allowAuthorizerOverride: ''},
    serviceType: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/domainConfigurations/:domainConfigurationName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"domainName":"","serverCertificateArns":[],"validationCertificateArn":"","authorizerConfig":{"defaultAuthorizerName":"","allowAuthorizerOverride":""},"serviceType":"","tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domainName": @"",
                              @"serverCertificateArns": @[  ],
                              @"validationCertificateArn": @"",
                              @"authorizerConfig": @{ @"defaultAuthorizerName": @"", @"allowAuthorizerOverride": @"" },
                              @"serviceType": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainConfigurations/:domainConfigurationName"]
                                                       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}}/domainConfigurations/:domainConfigurationName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/domainConfigurations/:domainConfigurationName",
  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([
    'domainName' => '',
    'serverCertificateArns' => [
        
    ],
    'validationCertificateArn' => '',
    'authorizerConfig' => [
        'defaultAuthorizerName' => '',
        'allowAuthorizerOverride' => ''
    ],
    'serviceType' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/domainConfigurations/:domainConfigurationName', [
  'body' => '{
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": {
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  },
  "serviceType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/domainConfigurations/:domainConfigurationName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domainName' => '',
  'serverCertificateArns' => [
    
  ],
  'validationCertificateArn' => '',
  'authorizerConfig' => [
    'defaultAuthorizerName' => '',
    'allowAuthorizerOverride' => ''
  ],
  'serviceType' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'domainName' => '',
  'serverCertificateArns' => [
    
  ],
  'validationCertificateArn' => '',
  'authorizerConfig' => [
    'defaultAuthorizerName' => '',
    'allowAuthorizerOverride' => ''
  ],
  'serviceType' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/domainConfigurations/:domainConfigurationName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainConfigurations/:domainConfigurationName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": {
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  },
  "serviceType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainConfigurations/:domainConfigurationName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": {
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  },
  "serviceType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

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

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

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

import requests

url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

payload = {
    "domainName": "",
    "serverCertificateArns": [],
    "validationCertificateArn": "",
    "authorizerConfig": {
        "defaultAuthorizerName": "",
        "allowAuthorizerOverride": ""
    },
    "serviceType": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

payload <- "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainConfigurations/:domainConfigurationName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/domainConfigurations/:domainConfigurationName') do |req|
  req.body = "{\n  \"domainName\": \"\",\n  \"serverCertificateArns\": [],\n  \"validationCertificateArn\": \"\",\n  \"authorizerConfig\": {\n    \"defaultAuthorizerName\": \"\",\n    \"allowAuthorizerOverride\": \"\"\n  },\n  \"serviceType\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName";

    let payload = json!({
        "domainName": "",
        "serverCertificateArns": (),
        "validationCertificateArn": "",
        "authorizerConfig": json!({
            "defaultAuthorizerName": "",
            "allowAuthorizerOverride": ""
        }),
        "serviceType": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": {
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  },
  "serviceType": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/domainConfigurations/:domainConfigurationName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "domainName": "",\n  "serverCertificateArns": [],\n  "validationCertificateArn": "",\n  "authorizerConfig": {\n    "defaultAuthorizerName": "",\n    "allowAuthorizerOverride": ""\n  },\n  "serviceType": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/domainConfigurations/:domainConfigurationName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "domainName": "",
  "serverCertificateArns": [],
  "validationCertificateArn": "",
  "authorizerConfig": [
    "defaultAuthorizerName": "",
    "allowAuthorizerOverride": ""
  ],
  "serviceType": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainConfigurations/:domainConfigurationName")! 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}}/dynamic-thing-groups/:thingGroupName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/dynamic-thing-groups/:thingGroupName" {:content-type :json
                                                                                 :form-params {:thingGroupProperties {:thingGroupDescription ""
                                                                                                                      :attributePayload ""}
                                                                                               :indexName ""
                                                                                               :queryString ""
                                                                                               :queryVersion ""
                                                                                               :tags [{:Key ""
                                                                                                       :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/dynamic-thing-groups/:thingGroupName"),
    Content = new StringContent("{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/dynamic-thing-groups/:thingGroupName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

	payload := strings.NewReader("{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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/dynamic-thing-groups/:thingGroupName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 221

{
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dynamic-thing-groups/:thingGroupName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .header("content-type", "application/json")
  .body("{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  thingGroupProperties: {
    thingGroupDescription: '',
    attributePayload: ''
  },
  indexName: '',
  queryString: '',
  queryVersion: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/dynamic-thing-groups/:thingGroupName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dynamic-thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    indexName: '',
    queryString: '',
    queryVersion: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/dynamic-thing-groups/:thingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingGroupProperties":{"thingGroupDescription":"","attributePayload":""},"indexName":"","queryString":"","queryVersion":"","tags":[{"Key":"","Value":""}]}'
};

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}}/dynamic-thing-groups/:thingGroupName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "thingGroupProperties": {\n    "thingGroupDescription": "",\n    "attributePayload": ""\n  },\n  "indexName": "",\n  "queryString": "",\n  "queryVersion": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .post(body)
  .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/dynamic-thing-groups/:thingGroupName',
  headers: {
    '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({
  thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
  indexName: '',
  queryString: '',
  queryVersion: '',
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dynamic-thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  body: {
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    indexName: '',
    queryString: '',
    queryVersion: '',
    tags: [{Key: '', Value: ''}]
  },
  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}}/dynamic-thing-groups/:thingGroupName');

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

req.type('json');
req.send({
  thingGroupProperties: {
    thingGroupDescription: '',
    attributePayload: ''
  },
  indexName: '',
  queryString: '',
  queryVersion: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/dynamic-thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    indexName: '',
    queryString: '',
    queryVersion: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/dynamic-thing-groups/:thingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingGroupProperties":{"thingGroupDescription":"","attributePayload":""},"indexName":"","queryString":"","queryVersion":"","tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"thingGroupProperties": @{ @"thingGroupDescription": @"", @"attributePayload": @"" },
                              @"indexName": @"",
                              @"queryString": @"",
                              @"queryVersion": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dynamic-thing-groups/:thingGroupName"]
                                                       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}}/dynamic-thing-groups/:thingGroupName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/dynamic-thing-groups/:thingGroupName",
  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([
    'thingGroupProperties' => [
        'thingGroupDescription' => '',
        'attributePayload' => ''
    ],
    'indexName' => '',
    'queryString' => '',
    'queryVersion' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/dynamic-thing-groups/:thingGroupName', [
  'body' => '{
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/dynamic-thing-groups/:thingGroupName');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'thingGroupProperties' => [
    'thingGroupDescription' => '',
    'attributePayload' => ''
  ],
  'indexName' => '',
  'queryString' => '',
  'queryVersion' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'thingGroupProperties' => [
    'thingGroupDescription' => '',
    'attributePayload' => ''
  ],
  'indexName' => '',
  'queryString' => '',
  'queryVersion' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/dynamic-thing-groups/:thingGroupName');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/dynamic-thing-groups/:thingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dynamic-thing-groups/:thingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/dynamic-thing-groups/:thingGroupName", payload, headers)

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

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

import requests

url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

payload = {
    "thingGroupProperties": {
        "thingGroupDescription": "",
        "attributePayload": ""
    },
    "indexName": "",
    "queryString": "",
    "queryVersion": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

payload <- "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/dynamic-thing-groups/:thingGroupName') do |req|
  req.body = "{\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"indexName\": \"\",\n  \"queryString\": \"\",\n  \"queryVersion\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName";

    let payload = json!({
        "thingGroupProperties": json!({
            "thingGroupDescription": "",
            "attributePayload": ""
        }),
        "indexName": "",
        "queryString": "",
        "queryVersion": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/dynamic-thing-groups/:thingGroupName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "thingGroupProperties": {\n    "thingGroupDescription": "",\n    "attributePayload": ""\n  },\n  "indexName": "",\n  "queryString": "",\n  "queryVersion": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/dynamic-thing-groups/:thingGroupName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "thingGroupProperties": [
    "thingGroupDescription": "",
    "attributePayload": ""
  ],
  "indexName": "",
  "queryString": "",
  "queryVersion": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dynamic-thing-groups/:thingGroupName")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/fleet-metric/:metricName");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/fleet-metric/:metricName" {:content-type :json
                                                                    :form-params {:queryString ""
                                                                                  :aggregationType {:name ""
                                                                                                    :values ""}
                                                                                  :period 0
                                                                                  :aggregationField ""
                                                                                  :description ""
                                                                                  :queryVersion ""
                                                                                  :indexName ""
                                                                                  :unit ""
                                                                                  :tags [{:Key ""
                                                                                          :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/fleet-metric/:metricName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/fleet-metric/:metricName"),
    Content = new StringContent("{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/fleet-metric/:metricName");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/fleet-metric/:metricName"

	payload := strings.NewReader("{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

	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))

}

PUT /baseUrl/fleet-metric/:metricName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 265

{
  "queryString": "",
  "aggregationType": {
    "name": "",
    "values": ""
  },
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/fleet-metric/:metricName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/fleet-metric/:metricName"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/fleet-metric/:metricName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/fleet-metric/:metricName")
  .header("content-type", "application/json")
  .body("{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  queryString: '',
  aggregationType: {
    name: '',
    values: ''
  },
  period: 0,
  aggregationField: '',
  description: '',
  queryVersion: '',
  indexName: '',
  unit: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('PUT', '{{baseUrl}}/fleet-metric/:metricName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fleet-metric/:metricName',
  headers: {'content-type': 'application/json'},
  data: {
    queryString: '',
    aggregationType: {name: '', values: ''},
    period: 0,
    aggregationField: '',
    description: '',
    queryVersion: '',
    indexName: '',
    unit: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/fleet-metric/:metricName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"queryString":"","aggregationType":{"name":"","values":""},"period":0,"aggregationField":"","description":"","queryVersion":"","indexName":"","unit":"","tags":[{"Key":"","Value":""}]}'
};

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}}/fleet-metric/:metricName',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "queryString": "",\n  "aggregationType": {\n    "name": "",\n    "values": ""\n  },\n  "period": 0,\n  "aggregationField": "",\n  "description": "",\n  "queryVersion": "",\n  "indexName": "",\n  "unit": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/fleet-metric/:metricName")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/fleet-metric/:metricName',
  headers: {
    '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({
  queryString: '',
  aggregationType: {name: '', values: ''},
  period: 0,
  aggregationField: '',
  description: '',
  queryVersion: '',
  indexName: '',
  unit: '',
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fleet-metric/:metricName',
  headers: {'content-type': 'application/json'},
  body: {
    queryString: '',
    aggregationType: {name: '', values: ''},
    period: 0,
    aggregationField: '',
    description: '',
    queryVersion: '',
    indexName: '',
    unit: '',
    tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/fleet-metric/:metricName');

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

req.type('json');
req.send({
  queryString: '',
  aggregationType: {
    name: '',
    values: ''
  },
  period: 0,
  aggregationField: '',
  description: '',
  queryVersion: '',
  indexName: '',
  unit: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/fleet-metric/:metricName',
  headers: {'content-type': 'application/json'},
  data: {
    queryString: '',
    aggregationType: {name: '', values: ''},
    period: 0,
    aggregationField: '',
    description: '',
    queryVersion: '',
    indexName: '',
    unit: '',
    tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/fleet-metric/:metricName';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"queryString":"","aggregationType":{"name":"","values":""},"period":0,"aggregationField":"","description":"","queryVersion":"","indexName":"","unit":"","tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"queryString": @"",
                              @"aggregationType": @{ @"name": @"", @"values": @"" },
                              @"period": @0,
                              @"aggregationField": @"",
                              @"description": @"",
                              @"queryVersion": @"",
                              @"indexName": @"",
                              @"unit": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/fleet-metric/:metricName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/fleet-metric/:metricName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/fleet-metric/:metricName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'queryString' => '',
    'aggregationType' => [
        'name' => '',
        'values' => ''
    ],
    'period' => 0,
    'aggregationField' => '',
    'description' => '',
    'queryVersion' => '',
    'indexName' => '',
    'unit' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/fleet-metric/:metricName', [
  'body' => '{
  "queryString": "",
  "aggregationType": {
    "name": "",
    "values": ""
  },
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/fleet-metric/:metricName');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'queryString' => '',
  'aggregationType' => [
    'name' => '',
    'values' => ''
  ],
  'period' => 0,
  'aggregationField' => '',
  'description' => '',
  'queryVersion' => '',
  'indexName' => '',
  'unit' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'queryString' => '',
  'aggregationType' => [
    'name' => '',
    'values' => ''
  ],
  'period' => 0,
  'aggregationField' => '',
  'description' => '',
  'queryVersion' => '',
  'indexName' => '',
  'unit' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/fleet-metric/:metricName');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/fleet-metric/:metricName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "queryString": "",
  "aggregationType": {
    "name": "",
    "values": ""
  },
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/fleet-metric/:metricName' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "queryString": "",
  "aggregationType": {
    "name": "",
    "values": ""
  },
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/fleet-metric/:metricName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/fleet-metric/:metricName"

payload = {
    "queryString": "",
    "aggregationType": {
        "name": "",
        "values": ""
    },
    "period": 0,
    "aggregationField": "",
    "description": "",
    "queryVersion": "",
    "indexName": "",
    "unit": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/fleet-metric/:metricName"

payload <- "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/fleet-metric/:metricName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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.put('/baseUrl/fleet-metric/:metricName') do |req|
  req.body = "{\n  \"queryString\": \"\",\n  \"aggregationType\": {\n    \"name\": \"\",\n    \"values\": \"\"\n  },\n  \"period\": 0,\n  \"aggregationField\": \"\",\n  \"description\": \"\",\n  \"queryVersion\": \"\",\n  \"indexName\": \"\",\n  \"unit\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/fleet-metric/:metricName";

    let payload = json!({
        "queryString": "",
        "aggregationType": json!({
            "name": "",
            "values": ""
        }),
        "period": 0,
        "aggregationField": "",
        "description": "",
        "queryVersion": "",
        "indexName": "",
        "unit": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "queryString": "",
  "aggregationType": {
    "name": "",
    "values": ""
  },
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/fleet-metric/:metricName \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "queryString": "",\n  "aggregationType": {\n    "name": "",\n    "values": ""\n  },\n  "period": 0,\n  "aggregationField": "",\n  "description": "",\n  "queryVersion": "",\n  "indexName": "",\n  "unit": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/fleet-metric/:metricName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "queryString": "",
  "aggregationType": [
    "name": "",
    "values": ""
  ],
  "period": 0,
  "aggregationField": "",
  "description": "",
  "queryVersion": "",
  "indexName": "",
  "unit": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/fleet-metric/:metricName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/jobs/:jobId");

struct curl_slist *headers = NULL;
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  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/jobs/:jobId" {:content-type :json
                                                       :form-params {:targets []
                                                                     :documentSource ""
                                                                     :document ""
                                                                     :description ""
                                                                     :presignedUrlConfig {:roleArn ""
                                                                                          :expiresInSec ""}
                                                                     :targetSelection ""
                                                                     :jobExecutionsRolloutConfig {:maximumPerMinute ""
                                                                                                  :exponentialRate ""}
                                                                     :abortConfig {:criteriaList ""}
                                                                     :timeoutConfig {:inProgressTimeoutInMinutes ""}
                                                                     :tags [{:Key ""
                                                                             :Value ""}]
                                                                     :namespaceId ""
                                                                     :jobTemplateArn ""
                                                                     :jobExecutionsRetryConfig {:criteriaList ""}
                                                                     :documentParameters {}
                                                                     :schedulingConfig {:startTime ""
                                                                                        :endTime ""
                                                                                        :endBehavior ""
                                                                                        :maintenanceWindows ""}}})

require "http/client"

url = "{{baseUrl}}/jobs/:jobId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/jobs/:jobId"),
    Content = new StringContent("{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\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}}/jobs/:jobId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/jobs/:jobId"

	payload := strings.NewReader("{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/jobs/:jobId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 701

{
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "targetSelection": "",
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "documentParameters": {},
  "schedulingConfig": {
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/jobs/:jobId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs/:jobId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\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  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/jobs/:jobId")
  .header("content-type", "application/json")
  .body("{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  targets: [],
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {
    roleArn: '',
    expiresInSec: ''
  },
  targetSelection: '',
  jobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  abortConfig: {
    criteriaList: ''
  },
  timeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  namespaceId: '',
  jobTemplateArn: '',
  jobExecutionsRetryConfig: {
    criteriaList: ''
  },
  documentParameters: {},
  schedulingConfig: {
    startTime: '',
    endTime: '',
    endBehavior: '',
    maintenanceWindows: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/jobs/:jobId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId',
  headers: {'content-type': 'application/json'},
  data: {
    targets: [],
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    targetSelection: '',
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    namespaceId: '',
    jobTemplateArn: '',
    jobExecutionsRetryConfig: {criteriaList: ''},
    documentParameters: {},
    schedulingConfig: {startTime: '', endTime: '', endBehavior: '', maintenanceWindows: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/jobs/:jobId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"targets":[],"documentSource":"","document":"","description":"","presignedUrlConfig":{"roleArn":"","expiresInSec":""},"targetSelection":"","jobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"abortConfig":{"criteriaList":""},"timeoutConfig":{"inProgressTimeoutInMinutes":""},"tags":[{"Key":"","Value":""}],"namespaceId":"","jobTemplateArn":"","jobExecutionsRetryConfig":{"criteriaList":""},"documentParameters":{},"schedulingConfig":{"startTime":"","endTime":"","endBehavior":"","maintenanceWindows":""}}'
};

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}}/jobs/:jobId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "targets": [],\n  "documentSource": "",\n  "document": "",\n  "description": "",\n  "presignedUrlConfig": {\n    "roleArn": "",\n    "expiresInSec": ""\n  },\n  "targetSelection": "",\n  "jobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "abortConfig": {\n    "criteriaList": ""\n  },\n  "timeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "namespaceId": "",\n  "jobTemplateArn": "",\n  "jobExecutionsRetryConfig": {\n    "criteriaList": ""\n  },\n  "documentParameters": {},\n  "schedulingConfig": {\n    "startTime": "",\n    "endTime": "",\n    "endBehavior": "",\n    "maintenanceWindows": ""\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  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jobs/:jobId',
  headers: {
    '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({
  targets: [],
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {roleArn: '', expiresInSec: ''},
  targetSelection: '',
  jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
  abortConfig: {criteriaList: ''},
  timeoutConfig: {inProgressTimeoutInMinutes: ''},
  tags: [{Key: '', Value: ''}],
  namespaceId: '',
  jobTemplateArn: '',
  jobExecutionsRetryConfig: {criteriaList: ''},
  documentParameters: {},
  schedulingConfig: {startTime: '', endTime: '', endBehavior: '', maintenanceWindows: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId',
  headers: {'content-type': 'application/json'},
  body: {
    targets: [],
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    targetSelection: '',
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    namespaceId: '',
    jobTemplateArn: '',
    jobExecutionsRetryConfig: {criteriaList: ''},
    documentParameters: {},
    schedulingConfig: {startTime: '', endTime: '', endBehavior: '', maintenanceWindows: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/jobs/:jobId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  targets: [],
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {
    roleArn: '',
    expiresInSec: ''
  },
  targetSelection: '',
  jobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  abortConfig: {
    criteriaList: ''
  },
  timeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  namespaceId: '',
  jobTemplateArn: '',
  jobExecutionsRetryConfig: {
    criteriaList: ''
  },
  documentParameters: {},
  schedulingConfig: {
    startTime: '',
    endTime: '',
    endBehavior: '',
    maintenanceWindows: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/jobs/:jobId',
  headers: {'content-type': 'application/json'},
  data: {
    targets: [],
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    targetSelection: '',
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    namespaceId: '',
    jobTemplateArn: '',
    jobExecutionsRetryConfig: {criteriaList: ''},
    documentParameters: {},
    schedulingConfig: {startTime: '', endTime: '', endBehavior: '', maintenanceWindows: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/jobs/:jobId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"targets":[],"documentSource":"","document":"","description":"","presignedUrlConfig":{"roleArn":"","expiresInSec":""},"targetSelection":"","jobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"abortConfig":{"criteriaList":""},"timeoutConfig":{"inProgressTimeoutInMinutes":""},"tags":[{"Key":"","Value":""}],"namespaceId":"","jobTemplateArn":"","jobExecutionsRetryConfig":{"criteriaList":""},"documentParameters":{},"schedulingConfig":{"startTime":"","endTime":"","endBehavior":"","maintenanceWindows":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"targets": @[  ],
                              @"documentSource": @"",
                              @"document": @"",
                              @"description": @"",
                              @"presignedUrlConfig": @{ @"roleArn": @"", @"expiresInSec": @"" },
                              @"targetSelection": @"",
                              @"jobExecutionsRolloutConfig": @{ @"maximumPerMinute": @"", @"exponentialRate": @"" },
                              @"abortConfig": @{ @"criteriaList": @"" },
                              @"timeoutConfig": @{ @"inProgressTimeoutInMinutes": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"namespaceId": @"",
                              @"jobTemplateArn": @"",
                              @"jobExecutionsRetryConfig": @{ @"criteriaList": @"" },
                              @"documentParameters": @{  },
                              @"schedulingConfig": @{ @"startTime": @"", @"endTime": @"", @"endBehavior": @"", @"maintenanceWindows": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/jobs/:jobId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/jobs/:jobId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/jobs/:jobId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'targets' => [
        
    ],
    'documentSource' => '',
    'document' => '',
    'description' => '',
    'presignedUrlConfig' => [
        'roleArn' => '',
        'expiresInSec' => ''
    ],
    'targetSelection' => '',
    'jobExecutionsRolloutConfig' => [
        'maximumPerMinute' => '',
        'exponentialRate' => ''
    ],
    'abortConfig' => [
        'criteriaList' => ''
    ],
    'timeoutConfig' => [
        'inProgressTimeoutInMinutes' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'namespaceId' => '',
    'jobTemplateArn' => '',
    'jobExecutionsRetryConfig' => [
        'criteriaList' => ''
    ],
    'documentParameters' => [
        
    ],
    'schedulingConfig' => [
        'startTime' => '',
        'endTime' => '',
        'endBehavior' => '',
        'maintenanceWindows' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/jobs/:jobId', [
  'body' => '{
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "targetSelection": "",
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "documentParameters": {},
  "schedulingConfig": {
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/jobs/:jobId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'targets' => [
    
  ],
  'documentSource' => '',
  'document' => '',
  'description' => '',
  'presignedUrlConfig' => [
    'roleArn' => '',
    'expiresInSec' => ''
  ],
  'targetSelection' => '',
  'jobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'abortConfig' => [
    'criteriaList' => ''
  ],
  'timeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'namespaceId' => '',
  'jobTemplateArn' => '',
  'jobExecutionsRetryConfig' => [
    'criteriaList' => ''
  ],
  'documentParameters' => [
    
  ],
  'schedulingConfig' => [
    'startTime' => '',
    'endTime' => '',
    'endBehavior' => '',
    'maintenanceWindows' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'targets' => [
    
  ],
  'documentSource' => '',
  'document' => '',
  'description' => '',
  'presignedUrlConfig' => [
    'roleArn' => '',
    'expiresInSec' => ''
  ],
  'targetSelection' => '',
  'jobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'abortConfig' => [
    'criteriaList' => ''
  ],
  'timeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'namespaceId' => '',
  'jobTemplateArn' => '',
  'jobExecutionsRetryConfig' => [
    'criteriaList' => ''
  ],
  'documentParameters' => [
    
  ],
  'schedulingConfig' => [
    'startTime' => '',
    'endTime' => '',
    'endBehavior' => '',
    'maintenanceWindows' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/jobs/:jobId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs/:jobId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "targetSelection": "",
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "documentParameters": {},
  "schedulingConfig": {
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs/:jobId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "targetSelection": "",
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "documentParameters": {},
  "schedulingConfig": {
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/jobs/:jobId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/jobs/:jobId"

payload = {
    "targets": [],
    "documentSource": "",
    "document": "",
    "description": "",
    "presignedUrlConfig": {
        "roleArn": "",
        "expiresInSec": ""
    },
    "targetSelection": "",
    "jobExecutionsRolloutConfig": {
        "maximumPerMinute": "",
        "exponentialRate": ""
    },
    "abortConfig": { "criteriaList": "" },
    "timeoutConfig": { "inProgressTimeoutInMinutes": "" },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "namespaceId": "",
    "jobTemplateArn": "",
    "jobExecutionsRetryConfig": { "criteriaList": "" },
    "documentParameters": {},
    "schedulingConfig": {
        "startTime": "",
        "endTime": "",
        "endBehavior": "",
        "maintenanceWindows": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/jobs/:jobId"

payload <- "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jobs/:jobId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\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.put('/baseUrl/jobs/:jobId') do |req|
  req.body = "{\n  \"targets\": [],\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"targetSelection\": \"\",\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"namespaceId\": \"\",\n  \"jobTemplateArn\": \"\",\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"documentParameters\": {},\n  \"schedulingConfig\": {\n    \"startTime\": \"\",\n    \"endTime\": \"\",\n    \"endBehavior\": \"\",\n    \"maintenanceWindows\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jobs/:jobId";

    let payload = json!({
        "targets": (),
        "documentSource": "",
        "document": "",
        "description": "",
        "presignedUrlConfig": json!({
            "roleArn": "",
            "expiresInSec": ""
        }),
        "targetSelection": "",
        "jobExecutionsRolloutConfig": json!({
            "maximumPerMinute": "",
            "exponentialRate": ""
        }),
        "abortConfig": json!({"criteriaList": ""}),
        "timeoutConfig": json!({"inProgressTimeoutInMinutes": ""}),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "namespaceId": "",
        "jobTemplateArn": "",
        "jobExecutionsRetryConfig": json!({"criteriaList": ""}),
        "documentParameters": json!({}),
        "schedulingConfig": json!({
            "startTime": "",
            "endTime": "",
            "endBehavior": "",
            "maintenanceWindows": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "targetSelection": "",
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "documentParameters": {},
  "schedulingConfig": {
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  }
}' |  \
  http PUT {{baseUrl}}/jobs/:jobId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "targets": [],\n  "documentSource": "",\n  "document": "",\n  "description": "",\n  "presignedUrlConfig": {\n    "roleArn": "",\n    "expiresInSec": ""\n  },\n  "targetSelection": "",\n  "jobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "abortConfig": {\n    "criteriaList": ""\n  },\n  "timeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "namespaceId": "",\n  "jobTemplateArn": "",\n  "jobExecutionsRetryConfig": {\n    "criteriaList": ""\n  },\n  "documentParameters": {},\n  "schedulingConfig": {\n    "startTime": "",\n    "endTime": "",\n    "endBehavior": "",\n    "maintenanceWindows": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/jobs/:jobId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "targets": [],
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": [
    "roleArn": "",
    "expiresInSec": ""
  ],
  "targetSelection": "",
  "jobExecutionsRolloutConfig": [
    "maximumPerMinute": "",
    "exponentialRate": ""
  ],
  "abortConfig": ["criteriaList": ""],
  "timeoutConfig": ["inProgressTimeoutInMinutes": ""],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "namespaceId": "",
  "jobTemplateArn": "",
  "jobExecutionsRetryConfig": ["criteriaList": ""],
  "documentParameters": [],
  "schedulingConfig": [
    "startTime": "",
    "endTime": "",
    "endBehavior": "",
    "maintenanceWindows": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jobs/:jobId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/job-templates/:jobTemplateId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/job-templates/:jobTemplateId" {:content-type :json
                                                                        :form-params {:jobArn ""
                                                                                      :documentSource ""
                                                                                      :document ""
                                                                                      :description ""
                                                                                      :presignedUrlConfig {:roleArn ""
                                                                                                           :expiresInSec ""}
                                                                                      :jobExecutionsRolloutConfig {:maximumPerMinute ""
                                                                                                                   :exponentialRate ""}
                                                                                      :abortConfig {:criteriaList ""}
                                                                                      :timeoutConfig {:inProgressTimeoutInMinutes ""}
                                                                                      :tags [{:Key ""
                                                                                              :Value ""}]
                                                                                      :jobExecutionsRetryConfig {:criteriaList ""}
                                                                                      :maintenanceWindows [{:startTime ""
                                                                                                            :durationInMinutes ""}]}})

require "http/client"

url = "{{baseUrl}}/job-templates/:jobTemplateId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/job-templates/:jobTemplateId"),
    Content = new StringContent("{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\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}}/job-templates/:jobTemplateId");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/job-templates/:jobTemplateId"

	payload := strings.NewReader("{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	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))

}

PUT /baseUrl/job-templates/:jobTemplateId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 577

{
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "maintenanceWindows": [
    {
      "startTime": "",
      "durationInMinutes": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/job-templates/:jobTemplateId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/job-templates/:jobTemplateId"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\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  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/job-templates/:jobTemplateId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/job-templates/:jobTemplateId")
  .header("content-type", "application/json")
  .body("{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  jobArn: '',
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {
    roleArn: '',
    expiresInSec: ''
  },
  jobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  abortConfig: {
    criteriaList: ''
  },
  timeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  jobExecutionsRetryConfig: {
    criteriaList: ''
  },
  maintenanceWindows: [
    {
      startTime: '',
      durationInMinutes: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/job-templates/:jobTemplateId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/job-templates/:jobTemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    jobArn: '',
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    jobExecutionsRetryConfig: {criteriaList: ''},
    maintenanceWindows: [{startTime: '', durationInMinutes: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/job-templates/:jobTemplateId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"jobArn":"","documentSource":"","document":"","description":"","presignedUrlConfig":{"roleArn":"","expiresInSec":""},"jobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"abortConfig":{"criteriaList":""},"timeoutConfig":{"inProgressTimeoutInMinutes":""},"tags":[{"Key":"","Value":""}],"jobExecutionsRetryConfig":{"criteriaList":""},"maintenanceWindows":[{"startTime":"","durationInMinutes":""}]}'
};

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}}/job-templates/:jobTemplateId',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobArn": "",\n  "documentSource": "",\n  "document": "",\n  "description": "",\n  "presignedUrlConfig": {\n    "roleArn": "",\n    "expiresInSec": ""\n  },\n  "jobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "abortConfig": {\n    "criteriaList": ""\n  },\n  "timeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "jobExecutionsRetryConfig": {\n    "criteriaList": ""\n  },\n  "maintenanceWindows": [\n    {\n      "startTime": "",\n      "durationInMinutes": ""\n    }\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  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/job-templates/:jobTemplateId")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/job-templates/:jobTemplateId',
  headers: {
    '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({
  jobArn: '',
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {roleArn: '', expiresInSec: ''},
  jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
  abortConfig: {criteriaList: ''},
  timeoutConfig: {inProgressTimeoutInMinutes: ''},
  tags: [{Key: '', Value: ''}],
  jobExecutionsRetryConfig: {criteriaList: ''},
  maintenanceWindows: [{startTime: '', durationInMinutes: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/job-templates/:jobTemplateId',
  headers: {'content-type': 'application/json'},
  body: {
    jobArn: '',
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    jobExecutionsRetryConfig: {criteriaList: ''},
    maintenanceWindows: [{startTime: '', durationInMinutes: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/job-templates/:jobTemplateId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  jobArn: '',
  documentSource: '',
  document: '',
  description: '',
  presignedUrlConfig: {
    roleArn: '',
    expiresInSec: ''
  },
  jobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  abortConfig: {
    criteriaList: ''
  },
  timeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  jobExecutionsRetryConfig: {
    criteriaList: ''
  },
  maintenanceWindows: [
    {
      startTime: '',
      durationInMinutes: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/job-templates/:jobTemplateId',
  headers: {'content-type': 'application/json'},
  data: {
    jobArn: '',
    documentSource: '',
    document: '',
    description: '',
    presignedUrlConfig: {roleArn: '', expiresInSec: ''},
    jobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    abortConfig: {criteriaList: ''},
    timeoutConfig: {inProgressTimeoutInMinutes: ''},
    tags: [{Key: '', Value: ''}],
    jobExecutionsRetryConfig: {criteriaList: ''},
    maintenanceWindows: [{startTime: '', durationInMinutes: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/job-templates/:jobTemplateId';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"jobArn":"","documentSource":"","document":"","description":"","presignedUrlConfig":{"roleArn":"","expiresInSec":""},"jobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"abortConfig":{"criteriaList":""},"timeoutConfig":{"inProgressTimeoutInMinutes":""},"tags":[{"Key":"","Value":""}],"jobExecutionsRetryConfig":{"criteriaList":""},"maintenanceWindows":[{"startTime":"","durationInMinutes":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"jobArn": @"",
                              @"documentSource": @"",
                              @"document": @"",
                              @"description": @"",
                              @"presignedUrlConfig": @{ @"roleArn": @"", @"expiresInSec": @"" },
                              @"jobExecutionsRolloutConfig": @{ @"maximumPerMinute": @"", @"exponentialRate": @"" },
                              @"abortConfig": @{ @"criteriaList": @"" },
                              @"timeoutConfig": @{ @"inProgressTimeoutInMinutes": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"jobExecutionsRetryConfig": @{ @"criteriaList": @"" },
                              @"maintenanceWindows": @[ @{ @"startTime": @"", @"durationInMinutes": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/job-templates/:jobTemplateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/job-templates/:jobTemplateId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/job-templates/:jobTemplateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'jobArn' => '',
    'documentSource' => '',
    'document' => '',
    'description' => '',
    'presignedUrlConfig' => [
        'roleArn' => '',
        'expiresInSec' => ''
    ],
    'jobExecutionsRolloutConfig' => [
        'maximumPerMinute' => '',
        'exponentialRate' => ''
    ],
    'abortConfig' => [
        'criteriaList' => ''
    ],
    'timeoutConfig' => [
        'inProgressTimeoutInMinutes' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'jobExecutionsRetryConfig' => [
        'criteriaList' => ''
    ],
    'maintenanceWindows' => [
        [
                'startTime' => '',
                'durationInMinutes' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/job-templates/:jobTemplateId', [
  'body' => '{
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "maintenanceWindows": [
    {
      "startTime": "",
      "durationInMinutes": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/job-templates/:jobTemplateId');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobArn' => '',
  'documentSource' => '',
  'document' => '',
  'description' => '',
  'presignedUrlConfig' => [
    'roleArn' => '',
    'expiresInSec' => ''
  ],
  'jobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'abortConfig' => [
    'criteriaList' => ''
  ],
  'timeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'jobExecutionsRetryConfig' => [
    'criteriaList' => ''
  ],
  'maintenanceWindows' => [
    [
        'startTime' => '',
        'durationInMinutes' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'jobArn' => '',
  'documentSource' => '',
  'document' => '',
  'description' => '',
  'presignedUrlConfig' => [
    'roleArn' => '',
    'expiresInSec' => ''
  ],
  'jobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'abortConfig' => [
    'criteriaList' => ''
  ],
  'timeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'jobExecutionsRetryConfig' => [
    'criteriaList' => ''
  ],
  'maintenanceWindows' => [
    [
        'startTime' => '',
        'durationInMinutes' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/job-templates/:jobTemplateId');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/job-templates/:jobTemplateId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "maintenanceWindows": [
    {
      "startTime": "",
      "durationInMinutes": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/job-templates/:jobTemplateId' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "maintenanceWindows": [
    {
      "startTime": "",
      "durationInMinutes": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/job-templates/:jobTemplateId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/job-templates/:jobTemplateId"

payload = {
    "jobArn": "",
    "documentSource": "",
    "document": "",
    "description": "",
    "presignedUrlConfig": {
        "roleArn": "",
        "expiresInSec": ""
    },
    "jobExecutionsRolloutConfig": {
        "maximumPerMinute": "",
        "exponentialRate": ""
    },
    "abortConfig": { "criteriaList": "" },
    "timeoutConfig": { "inProgressTimeoutInMinutes": "" },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "jobExecutionsRetryConfig": { "criteriaList": "" },
    "maintenanceWindows": [
        {
            "startTime": "",
            "durationInMinutes": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/job-templates/:jobTemplateId"

payload <- "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/job-templates/:jobTemplateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\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.put('/baseUrl/job-templates/:jobTemplateId') do |req|
  req.body = "{\n  \"jobArn\": \"\",\n  \"documentSource\": \"\",\n  \"document\": \"\",\n  \"description\": \"\",\n  \"presignedUrlConfig\": {\n    \"roleArn\": \"\",\n    \"expiresInSec\": \"\"\n  },\n  \"jobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"abortConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"timeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"jobExecutionsRetryConfig\": {\n    \"criteriaList\": \"\"\n  },\n  \"maintenanceWindows\": [\n    {\n      \"startTime\": \"\",\n      \"durationInMinutes\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/job-templates/:jobTemplateId";

    let payload = json!({
        "jobArn": "",
        "documentSource": "",
        "document": "",
        "description": "",
        "presignedUrlConfig": json!({
            "roleArn": "",
            "expiresInSec": ""
        }),
        "jobExecutionsRolloutConfig": json!({
            "maximumPerMinute": "",
            "exponentialRate": ""
        }),
        "abortConfig": json!({"criteriaList": ""}),
        "timeoutConfig": json!({"inProgressTimeoutInMinutes": ""}),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "jobExecutionsRetryConfig": json!({"criteriaList": ""}),
        "maintenanceWindows": (
            json!({
                "startTime": "",
                "durationInMinutes": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": {
    "roleArn": "",
    "expiresInSec": ""
  },
  "jobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "abortConfig": {
    "criteriaList": ""
  },
  "timeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "jobExecutionsRetryConfig": {
    "criteriaList": ""
  },
  "maintenanceWindows": [
    {
      "startTime": "",
      "durationInMinutes": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/job-templates/:jobTemplateId \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobArn": "",\n  "documentSource": "",\n  "document": "",\n  "description": "",\n  "presignedUrlConfig": {\n    "roleArn": "",\n    "expiresInSec": ""\n  },\n  "jobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "abortConfig": {\n    "criteriaList": ""\n  },\n  "timeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "jobExecutionsRetryConfig": {\n    "criteriaList": ""\n  },\n  "maintenanceWindows": [\n    {\n      "startTime": "",\n      "durationInMinutes": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/job-templates/:jobTemplateId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobArn": "",
  "documentSource": "",
  "document": "",
  "description": "",
  "presignedUrlConfig": [
    "roleArn": "",
    "expiresInSec": ""
  ],
  "jobExecutionsRolloutConfig": [
    "maximumPerMinute": "",
    "exponentialRate": ""
  ],
  "abortConfig": ["criteriaList": ""],
  "timeoutConfig": ["inProgressTimeoutInMinutes": ""],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "jobExecutionsRetryConfig": ["criteriaList": ""],
  "maintenanceWindows": [
    [
      "startTime": "",
      "durationInMinutes": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/job-templates/:jobTemplateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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}}/keys-and-certificate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/keys-and-certificate")

require "http/client"

url = "{{baseUrl}}/keys-and-certificate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/keys-and-certificate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/keys-and-certificate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/keys-and-certificate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/keys-and-certificate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/keys-and-certificate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/keys-and-certificate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/keys-and-certificate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/keys-and-certificate")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/keys-and-certificate');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/keys-and-certificate'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/keys-and-certificate';
const options = {method: 'POST'};

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}}/keys-and-certificate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/keys-and-certificate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/keys-and-certificate',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/keys-and-certificate'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/keys-and-certificate');

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}}/keys-and-certificate'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/keys-and-certificate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/keys-and-certificate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/keys-and-certificate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/keys-and-certificate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/keys-and-certificate');

echo $response->getBody();

setUrl('{{baseUrl}}/keys-and-certificate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/keys-and-certificate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/keys-and-certificate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/keys-and-certificate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/keys-and-certificate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/keys-and-certificate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/keys-and-certificate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/keys-and-certificate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/keys-and-certificate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/keys-and-certificate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/keys-and-certificate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/keys-and-certificate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/keys-and-certificate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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}}/mitigationactions/actions/:actionName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/mitigationactions/actions/:actionName" {:content-type :json
                                                                                  :form-params {:roleArn ""
                                                                                                :actionParams {:updateDeviceCertificateParams ""
                                                                                                               :updateCACertificateParams ""
                                                                                                               :addThingsToThingGroupParams ""
                                                                                                               :replaceDefaultPolicyVersionParams ""
                                                                                                               :enableIoTLoggingParams ""
                                                                                                               :publishFindingToSnsParams ""}
                                                                                                :tags [{:Key ""
                                                                                                        :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/mitigationactions/actions/:actionName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/mitigationactions/actions/:actionName"),
    Content = new StringContent("{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/mitigationactions/actions/:actionName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/mitigationactions/actions/:actionName"

	payload := strings.NewReader("{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/mitigationactions/actions/:actionName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 340

{
  "roleArn": "",
  "actionParams": {
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/mitigationactions/actions/:actionName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/mitigationactions/actions/:actionName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/mitigationactions/actions/:actionName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/mitigationactions/actions/:actionName")
  .header("content-type", "application/json")
  .body("{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  roleArn: '',
  actionParams: {
    updateDeviceCertificateParams: '',
    updateCACertificateParams: '',
    addThingsToThingGroupParams: '',
    replaceDefaultPolicyVersionParams: '',
    enableIoTLoggingParams: '',
    publishFindingToSnsParams: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/mitigationactions/actions/:actionName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/mitigationactions/actions/:actionName',
  headers: {'content-type': 'application/json'},
  data: {
    roleArn: '',
    actionParams: {
      updateDeviceCertificateParams: '',
      updateCACertificateParams: '',
      addThingsToThingGroupParams: '',
      replaceDefaultPolicyVersionParams: '',
      enableIoTLoggingParams: '',
      publishFindingToSnsParams: ''
    },
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/mitigationactions/actions/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleArn":"","actionParams":{"updateDeviceCertificateParams":"","updateCACertificateParams":"","addThingsToThingGroupParams":"","replaceDefaultPolicyVersionParams":"","enableIoTLoggingParams":"","publishFindingToSnsParams":""},"tags":[{"Key":"","Value":""}]}'
};

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}}/mitigationactions/actions/:actionName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleArn": "",\n  "actionParams": {\n    "updateDeviceCertificateParams": "",\n    "updateCACertificateParams": "",\n    "addThingsToThingGroupParams": "",\n    "replaceDefaultPolicyVersionParams": "",\n    "enableIoTLoggingParams": "",\n    "publishFindingToSnsParams": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/mitigationactions/actions/:actionName")
  .post(body)
  .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/mitigationactions/actions/:actionName',
  headers: {
    '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({
  roleArn: '',
  actionParams: {
    updateDeviceCertificateParams: '',
    updateCACertificateParams: '',
    addThingsToThingGroupParams: '',
    replaceDefaultPolicyVersionParams: '',
    enableIoTLoggingParams: '',
    publishFindingToSnsParams: ''
  },
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/mitigationactions/actions/:actionName',
  headers: {'content-type': 'application/json'},
  body: {
    roleArn: '',
    actionParams: {
      updateDeviceCertificateParams: '',
      updateCACertificateParams: '',
      addThingsToThingGroupParams: '',
      replaceDefaultPolicyVersionParams: '',
      enableIoTLoggingParams: '',
      publishFindingToSnsParams: ''
    },
    tags: [{Key: '', Value: ''}]
  },
  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}}/mitigationactions/actions/:actionName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleArn: '',
  actionParams: {
    updateDeviceCertificateParams: '',
    updateCACertificateParams: '',
    addThingsToThingGroupParams: '',
    replaceDefaultPolicyVersionParams: '',
    enableIoTLoggingParams: '',
    publishFindingToSnsParams: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/mitigationactions/actions/:actionName',
  headers: {'content-type': 'application/json'},
  data: {
    roleArn: '',
    actionParams: {
      updateDeviceCertificateParams: '',
      updateCACertificateParams: '',
      addThingsToThingGroupParams: '',
      replaceDefaultPolicyVersionParams: '',
      enableIoTLoggingParams: '',
      publishFindingToSnsParams: ''
    },
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/mitigationactions/actions/:actionName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleArn":"","actionParams":{"updateDeviceCertificateParams":"","updateCACertificateParams":"","addThingsToThingGroupParams":"","replaceDefaultPolicyVersionParams":"","enableIoTLoggingParams":"","publishFindingToSnsParams":""},"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"roleArn": @"",
                              @"actionParams": @{ @"updateDeviceCertificateParams": @"", @"updateCACertificateParams": @"", @"addThingsToThingGroupParams": @"", @"replaceDefaultPolicyVersionParams": @"", @"enableIoTLoggingParams": @"", @"publishFindingToSnsParams": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/mitigationactions/actions/:actionName"]
                                                       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}}/mitigationactions/actions/:actionName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/mitigationactions/actions/:actionName",
  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([
    'roleArn' => '',
    'actionParams' => [
        'updateDeviceCertificateParams' => '',
        'updateCACertificateParams' => '',
        'addThingsToThingGroupParams' => '',
        'replaceDefaultPolicyVersionParams' => '',
        'enableIoTLoggingParams' => '',
        'publishFindingToSnsParams' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/mitigationactions/actions/:actionName', [
  'body' => '{
  "roleArn": "",
  "actionParams": {
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/mitigationactions/actions/:actionName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleArn' => '',
  'actionParams' => [
    'updateDeviceCertificateParams' => '',
    'updateCACertificateParams' => '',
    'addThingsToThingGroupParams' => '',
    'replaceDefaultPolicyVersionParams' => '',
    'enableIoTLoggingParams' => '',
    'publishFindingToSnsParams' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleArn' => '',
  'actionParams' => [
    'updateDeviceCertificateParams' => '',
    'updateCACertificateParams' => '',
    'addThingsToThingGroupParams' => '',
    'replaceDefaultPolicyVersionParams' => '',
    'enableIoTLoggingParams' => '',
    'publishFindingToSnsParams' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/mitigationactions/actions/:actionName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/mitigationactions/actions/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleArn": "",
  "actionParams": {
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/mitigationactions/actions/:actionName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleArn": "",
  "actionParams": {
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/mitigationactions/actions/:actionName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/mitigationactions/actions/:actionName"

payload = {
    "roleArn": "",
    "actionParams": {
        "updateDeviceCertificateParams": "",
        "updateCACertificateParams": "",
        "addThingsToThingGroupParams": "",
        "replaceDefaultPolicyVersionParams": "",
        "enableIoTLoggingParams": "",
        "publishFindingToSnsParams": ""
    },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/mitigationactions/actions/:actionName"

payload <- "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/mitigationactions/actions/:actionName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/mitigationactions/actions/:actionName') do |req|
  req.body = "{\n  \"roleArn\": \"\",\n  \"actionParams\": {\n    \"updateDeviceCertificateParams\": \"\",\n    \"updateCACertificateParams\": \"\",\n    \"addThingsToThingGroupParams\": \"\",\n    \"replaceDefaultPolicyVersionParams\": \"\",\n    \"enableIoTLoggingParams\": \"\",\n    \"publishFindingToSnsParams\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/mitigationactions/actions/:actionName";

    let payload = json!({
        "roleArn": "",
        "actionParams": json!({
            "updateDeviceCertificateParams": "",
            "updateCACertificateParams": "",
            "addThingsToThingGroupParams": "",
            "replaceDefaultPolicyVersionParams": "",
            "enableIoTLoggingParams": "",
            "publishFindingToSnsParams": ""
        }),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "roleArn": "",
  "actionParams": {
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/mitigationactions/actions/:actionName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleArn": "",\n  "actionParams": {\n    "updateDeviceCertificateParams": "",\n    "updateCACertificateParams": "",\n    "addThingsToThingGroupParams": "",\n    "replaceDefaultPolicyVersionParams": "",\n    "enableIoTLoggingParams": "",\n    "publishFindingToSnsParams": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/mitigationactions/actions/:actionName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleArn": "",
  "actionParams": [
    "updateDeviceCertificateParams": "",
    "updateCACertificateParams": "",
    "addThingsToThingGroupParams": "",
    "replaceDefaultPolicyVersionParams": "",
    "enableIoTLoggingParams": "",
    "publishFindingToSnsParams": ""
  ],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/mitigationactions/actions/:actionName")! 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}}/otaUpdates/:otaUpdateId");

struct curl_slist *headers = NULL;
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  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/otaUpdates/:otaUpdateId" {:content-type :json
                                                                    :form-params {:description ""
                                                                                  :targets []
                                                                                  :protocols []
                                                                                  :targetSelection ""
                                                                                  :awsJobExecutionsRolloutConfig {:maximumPerMinute ""
                                                                                                                  :exponentialRate ""}
                                                                                  :awsJobPresignedUrlConfig {:expiresInSec ""}
                                                                                  :awsJobAbortConfig {:abortCriteriaList ""}
                                                                                  :awsJobTimeoutConfig {:inProgressTimeoutInMinutes ""}
                                                                                  :files [{:fileName ""
                                                                                           :fileType ""
                                                                                           :fileVersion ""
                                                                                           :fileLocation ""
                                                                                           :codeSigning ""
                                                                                           :attributes ""}]
                                                                                  :roleArn ""
                                                                                  :additionalParameters {}
                                                                                  :tags [{:Key ""
                                                                                          :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/otaUpdates/:otaUpdateId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/otaUpdates/:otaUpdateId"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/otaUpdates/:otaUpdateId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/otaUpdates/:otaUpdateId"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/otaUpdates/:otaUpdateId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 651

{
  "description": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": ""
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": ""
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "files": [
    {
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    }
  ],
  "roleArn": "",
  "additionalParameters": {},
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/otaUpdates/:otaUpdateId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/otaUpdates/:otaUpdateId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/otaUpdates/:otaUpdateId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/otaUpdates/:otaUpdateId")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  targets: [],
  protocols: [],
  targetSelection: '',
  awsJobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  awsJobPresignedUrlConfig: {
    expiresInSec: ''
  },
  awsJobAbortConfig: {
    abortCriteriaList: ''
  },
  awsJobTimeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  files: [
    {
      fileName: '',
      fileType: '',
      fileVersion: '',
      fileLocation: '',
      codeSigning: '',
      attributes: ''
    }
  ],
  roleArn: '',
  additionalParameters: {},
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/otaUpdates/:otaUpdateId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/otaUpdates/:otaUpdateId',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    targets: [],
    protocols: [],
    targetSelection: '',
    awsJobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    awsJobPresignedUrlConfig: {expiresInSec: ''},
    awsJobAbortConfig: {abortCriteriaList: ''},
    awsJobTimeoutConfig: {inProgressTimeoutInMinutes: ''},
    files: [
      {
        fileName: '',
        fileType: '',
        fileVersion: '',
        fileLocation: '',
        codeSigning: '',
        attributes: ''
      }
    ],
    roleArn: '',
    additionalParameters: {},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/otaUpdates/:otaUpdateId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","targets":[],"protocols":[],"targetSelection":"","awsJobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"awsJobPresignedUrlConfig":{"expiresInSec":""},"awsJobAbortConfig":{"abortCriteriaList":""},"awsJobTimeoutConfig":{"inProgressTimeoutInMinutes":""},"files":[{"fileName":"","fileType":"","fileVersion":"","fileLocation":"","codeSigning":"","attributes":""}],"roleArn":"","additionalParameters":{},"tags":[{"Key":"","Value":""}]}'
};

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}}/otaUpdates/:otaUpdateId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "targets": [],\n  "protocols": [],\n  "targetSelection": "",\n  "awsJobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "awsJobPresignedUrlConfig": {\n    "expiresInSec": ""\n  },\n  "awsJobAbortConfig": {\n    "abortCriteriaList": ""\n  },\n  "awsJobTimeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "files": [\n    {\n      "fileName": "",\n      "fileType": "",\n      "fileVersion": "",\n      "fileLocation": "",\n      "codeSigning": "",\n      "attributes": ""\n    }\n  ],\n  "roleArn": "",\n  "additionalParameters": {},\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/otaUpdates/:otaUpdateId")
  .post(body)
  .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/otaUpdates/:otaUpdateId',
  headers: {
    '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: '',
  targets: [],
  protocols: [],
  targetSelection: '',
  awsJobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
  awsJobPresignedUrlConfig: {expiresInSec: ''},
  awsJobAbortConfig: {abortCriteriaList: ''},
  awsJobTimeoutConfig: {inProgressTimeoutInMinutes: ''},
  files: [
    {
      fileName: '',
      fileType: '',
      fileVersion: '',
      fileLocation: '',
      codeSigning: '',
      attributes: ''
    }
  ],
  roleArn: '',
  additionalParameters: {},
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/otaUpdates/:otaUpdateId',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    targets: [],
    protocols: [],
    targetSelection: '',
    awsJobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    awsJobPresignedUrlConfig: {expiresInSec: ''},
    awsJobAbortConfig: {abortCriteriaList: ''},
    awsJobTimeoutConfig: {inProgressTimeoutInMinutes: ''},
    files: [
      {
        fileName: '',
        fileType: '',
        fileVersion: '',
        fileLocation: '',
        codeSigning: '',
        attributes: ''
      }
    ],
    roleArn: '',
    additionalParameters: {},
    tags: [{Key: '', Value: ''}]
  },
  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}}/otaUpdates/:otaUpdateId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  targets: [],
  protocols: [],
  targetSelection: '',
  awsJobExecutionsRolloutConfig: {
    maximumPerMinute: '',
    exponentialRate: ''
  },
  awsJobPresignedUrlConfig: {
    expiresInSec: ''
  },
  awsJobAbortConfig: {
    abortCriteriaList: ''
  },
  awsJobTimeoutConfig: {
    inProgressTimeoutInMinutes: ''
  },
  files: [
    {
      fileName: '',
      fileType: '',
      fileVersion: '',
      fileLocation: '',
      codeSigning: '',
      attributes: ''
    }
  ],
  roleArn: '',
  additionalParameters: {},
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/otaUpdates/:otaUpdateId',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    targets: [],
    protocols: [],
    targetSelection: '',
    awsJobExecutionsRolloutConfig: {maximumPerMinute: '', exponentialRate: ''},
    awsJobPresignedUrlConfig: {expiresInSec: ''},
    awsJobAbortConfig: {abortCriteriaList: ''},
    awsJobTimeoutConfig: {inProgressTimeoutInMinutes: ''},
    files: [
      {
        fileName: '',
        fileType: '',
        fileVersion: '',
        fileLocation: '',
        codeSigning: '',
        attributes: ''
      }
    ],
    roleArn: '',
    additionalParameters: {},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/otaUpdates/:otaUpdateId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","targets":[],"protocols":[],"targetSelection":"","awsJobExecutionsRolloutConfig":{"maximumPerMinute":"","exponentialRate":""},"awsJobPresignedUrlConfig":{"expiresInSec":""},"awsJobAbortConfig":{"abortCriteriaList":""},"awsJobTimeoutConfig":{"inProgressTimeoutInMinutes":""},"files":[{"fileName":"","fileType":"","fileVersion":"","fileLocation":"","codeSigning":"","attributes":""}],"roleArn":"","additionalParameters":{},"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"targets": @[  ],
                              @"protocols": @[  ],
                              @"targetSelection": @"",
                              @"awsJobExecutionsRolloutConfig": @{ @"maximumPerMinute": @"", @"exponentialRate": @"" },
                              @"awsJobPresignedUrlConfig": @{ @"expiresInSec": @"" },
                              @"awsJobAbortConfig": @{ @"abortCriteriaList": @"" },
                              @"awsJobTimeoutConfig": @{ @"inProgressTimeoutInMinutes": @"" },
                              @"files": @[ @{ @"fileName": @"", @"fileType": @"", @"fileVersion": @"", @"fileLocation": @"", @"codeSigning": @"", @"attributes": @"" } ],
                              @"roleArn": @"",
                              @"additionalParameters": @{  },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/otaUpdates/:otaUpdateId"]
                                                       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}}/otaUpdates/:otaUpdateId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/otaUpdates/:otaUpdateId",
  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' => '',
    'targets' => [
        
    ],
    'protocols' => [
        
    ],
    'targetSelection' => '',
    'awsJobExecutionsRolloutConfig' => [
        'maximumPerMinute' => '',
        'exponentialRate' => ''
    ],
    'awsJobPresignedUrlConfig' => [
        'expiresInSec' => ''
    ],
    'awsJobAbortConfig' => [
        'abortCriteriaList' => ''
    ],
    'awsJobTimeoutConfig' => [
        'inProgressTimeoutInMinutes' => ''
    ],
    'files' => [
        [
                'fileName' => '',
                'fileType' => '',
                'fileVersion' => '',
                'fileLocation' => '',
                'codeSigning' => '',
                'attributes' => ''
        ]
    ],
    'roleArn' => '',
    'additionalParameters' => [
        
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/otaUpdates/:otaUpdateId', [
  'body' => '{
  "description": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": ""
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": ""
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "files": [
    {
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    }
  ],
  "roleArn": "",
  "additionalParameters": {},
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/otaUpdates/:otaUpdateId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'targets' => [
    
  ],
  'protocols' => [
    
  ],
  'targetSelection' => '',
  'awsJobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'awsJobPresignedUrlConfig' => [
    'expiresInSec' => ''
  ],
  'awsJobAbortConfig' => [
    'abortCriteriaList' => ''
  ],
  'awsJobTimeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'files' => [
    [
        'fileName' => '',
        'fileType' => '',
        'fileVersion' => '',
        'fileLocation' => '',
        'codeSigning' => '',
        'attributes' => ''
    ]
  ],
  'roleArn' => '',
  'additionalParameters' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'targets' => [
    
  ],
  'protocols' => [
    
  ],
  'targetSelection' => '',
  'awsJobExecutionsRolloutConfig' => [
    'maximumPerMinute' => '',
    'exponentialRate' => ''
  ],
  'awsJobPresignedUrlConfig' => [
    'expiresInSec' => ''
  ],
  'awsJobAbortConfig' => [
    'abortCriteriaList' => ''
  ],
  'awsJobTimeoutConfig' => [
    'inProgressTimeoutInMinutes' => ''
  ],
  'files' => [
    [
        'fileName' => '',
        'fileType' => '',
        'fileVersion' => '',
        'fileLocation' => '',
        'codeSigning' => '',
        'attributes' => ''
    ]
  ],
  'roleArn' => '',
  'additionalParameters' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/otaUpdates/:otaUpdateId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/otaUpdates/:otaUpdateId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": ""
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": ""
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "files": [
    {
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    }
  ],
  "roleArn": "",
  "additionalParameters": {},
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/otaUpdates/:otaUpdateId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": ""
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": ""
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "files": [
    {
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    }
  ],
  "roleArn": "",
  "additionalParameters": {},
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/otaUpdates/:otaUpdateId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/otaUpdates/:otaUpdateId"

payload = {
    "description": "",
    "targets": [],
    "protocols": [],
    "targetSelection": "",
    "awsJobExecutionsRolloutConfig": {
        "maximumPerMinute": "",
        "exponentialRate": ""
    },
    "awsJobPresignedUrlConfig": { "expiresInSec": "" },
    "awsJobAbortConfig": { "abortCriteriaList": "" },
    "awsJobTimeoutConfig": { "inProgressTimeoutInMinutes": "" },
    "files": [
        {
            "fileName": "",
            "fileType": "",
            "fileVersion": "",
            "fileLocation": "",
            "codeSigning": "",
            "attributes": ""
        }
    ],
    "roleArn": "",
    "additionalParameters": {},
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/otaUpdates/:otaUpdateId"

payload <- "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/otaUpdates/:otaUpdateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/otaUpdates/:otaUpdateId') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"targets\": [],\n  \"protocols\": [],\n  \"targetSelection\": \"\",\n  \"awsJobExecutionsRolloutConfig\": {\n    \"maximumPerMinute\": \"\",\n    \"exponentialRate\": \"\"\n  },\n  \"awsJobPresignedUrlConfig\": {\n    \"expiresInSec\": \"\"\n  },\n  \"awsJobAbortConfig\": {\n    \"abortCriteriaList\": \"\"\n  },\n  \"awsJobTimeoutConfig\": {\n    \"inProgressTimeoutInMinutes\": \"\"\n  },\n  \"files\": [\n    {\n      \"fileName\": \"\",\n      \"fileType\": \"\",\n      \"fileVersion\": \"\",\n      \"fileLocation\": \"\",\n      \"codeSigning\": \"\",\n      \"attributes\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"additionalParameters\": {},\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/otaUpdates/:otaUpdateId";

    let payload = json!({
        "description": "",
        "targets": (),
        "protocols": (),
        "targetSelection": "",
        "awsJobExecutionsRolloutConfig": json!({
            "maximumPerMinute": "",
            "exponentialRate": ""
        }),
        "awsJobPresignedUrlConfig": json!({"expiresInSec": ""}),
        "awsJobAbortConfig": json!({"abortCriteriaList": ""}),
        "awsJobTimeoutConfig": json!({"inProgressTimeoutInMinutes": ""}),
        "files": (
            json!({
                "fileName": "",
                "fileType": "",
                "fileVersion": "",
                "fileLocation": "",
                "codeSigning": "",
                "attributes": ""
            })
        ),
        "roleArn": "",
        "additionalParameters": json!({}),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": {
    "maximumPerMinute": "",
    "exponentialRate": ""
  },
  "awsJobPresignedUrlConfig": {
    "expiresInSec": ""
  },
  "awsJobAbortConfig": {
    "abortCriteriaList": ""
  },
  "awsJobTimeoutConfig": {
    "inProgressTimeoutInMinutes": ""
  },
  "files": [
    {
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    }
  ],
  "roleArn": "",
  "additionalParameters": {},
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/otaUpdates/:otaUpdateId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "targets": [],\n  "protocols": [],\n  "targetSelection": "",\n  "awsJobExecutionsRolloutConfig": {\n    "maximumPerMinute": "",\n    "exponentialRate": ""\n  },\n  "awsJobPresignedUrlConfig": {\n    "expiresInSec": ""\n  },\n  "awsJobAbortConfig": {\n    "abortCriteriaList": ""\n  },\n  "awsJobTimeoutConfig": {\n    "inProgressTimeoutInMinutes": ""\n  },\n  "files": [\n    {\n      "fileName": "",\n      "fileType": "",\n      "fileVersion": "",\n      "fileLocation": "",\n      "codeSigning": "",\n      "attributes": ""\n    }\n  ],\n  "roleArn": "",\n  "additionalParameters": {},\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/otaUpdates/:otaUpdateId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "targets": [],
  "protocols": [],
  "targetSelection": "",
  "awsJobExecutionsRolloutConfig": [
    "maximumPerMinute": "",
    "exponentialRate": ""
  ],
  "awsJobPresignedUrlConfig": ["expiresInSec": ""],
  "awsJobAbortConfig": ["abortCriteriaList": ""],
  "awsJobTimeoutConfig": ["inProgressTimeoutInMinutes": ""],
  "files": [
    [
      "fileName": "",
      "fileType": "",
      "fileVersion": "",
      "fileLocation": "",
      "codeSigning": "",
      "attributes": ""
    ]
  ],
  "roleArn": "",
  "additionalParameters": [],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/otaUpdates/:otaUpdateId")! 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}}/policies/:policyName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/policies/:policyName" {:content-type :json
                                                                 :form-params {:policyDocument ""
                                                                               :tags [{:Key ""
                                                                                       :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/policies/:policyName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/policies/:policyName"),
    Content = new StringContent("{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/policies/:policyName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/policies/:policyName"

	payload := strings.NewReader("{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/policies/:policyName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 90

{
  "policyDocument": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/policies/:policyName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/policies/:policyName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/policies/:policyName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/policies/:policyName")
  .header("content-type", "application/json")
  .body("{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  policyDocument: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/policies/:policyName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/policies/:policyName',
  headers: {'content-type': 'application/json'},
  data: {policyDocument: '', tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/policies/:policyName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policyDocument":"","tags":[{"Key":"","Value":""}]}'
};

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}}/policies/:policyName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "policyDocument": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/policies/:policyName")
  .post(body)
  .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/policies/:policyName',
  headers: {
    '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({policyDocument: '', tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/policies/:policyName',
  headers: {'content-type': 'application/json'},
  body: {policyDocument: '', tags: [{Key: '', Value: ''}]},
  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}}/policies/:policyName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  policyDocument: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/policies/:policyName',
  headers: {'content-type': 'application/json'},
  data: {policyDocument: '', tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/policies/:policyName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policyDocument":"","tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"policyDocument": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/policies/:policyName"]
                                                       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}}/policies/:policyName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/policies/:policyName",
  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([
    'policyDocument' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/policies/:policyName', [
  'body' => '{
  "policyDocument": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/policies/:policyName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'policyDocument' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'policyDocument' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/policies/:policyName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/policies/:policyName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policyDocument": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/policies/:policyName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policyDocument": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/policies/:policyName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/policies/:policyName"

payload = {
    "policyDocument": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/policies/:policyName"

payload <- "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/policies/:policyName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/policies/:policyName') do |req|
  req.body = "{\n  \"policyDocument\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/policies/:policyName";

    let payload = json!({
        "policyDocument": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "policyDocument": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/policies/:policyName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "policyDocument": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/policies/:policyName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "policyDocument": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/policies/:policyName")! 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}}/policies/:policyName/version");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"policyDocument\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/policies/:policyName/version" {:content-type :json
                                                                         :form-params {:policyDocument ""}})

require "http/client"

url = "{{baseUrl}}/policies/:policyName/version"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"policyDocument\": \"\"\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}}/policies/:policyName/version"),
    Content = new StringContent("{\n  \"policyDocument\": \"\"\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}}/policies/:policyName/version");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"policyDocument\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/policies/:policyName/version"

	payload := strings.NewReader("{\n  \"policyDocument\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/policies/:policyName/version HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "policyDocument": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/policies/:policyName/version")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"policyDocument\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/policies/:policyName/version"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"policyDocument\": \"\"\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  \"policyDocument\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/policies/:policyName/version")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/policies/:policyName/version")
  .header("content-type", "application/json")
  .body("{\n  \"policyDocument\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  policyDocument: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/policies/:policyName/version');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/policies/:policyName/version',
  headers: {'content-type': 'application/json'},
  data: {policyDocument: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/policies/:policyName/version';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policyDocument":""}'
};

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}}/policies/:policyName/version',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "policyDocument": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"policyDocument\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/policies/:policyName/version")
  .post(body)
  .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/policies/:policyName/version',
  headers: {
    '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({policyDocument: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/policies/:policyName/version',
  headers: {'content-type': 'application/json'},
  body: {policyDocument: ''},
  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}}/policies/:policyName/version');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  policyDocument: ''
});

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}}/policies/:policyName/version',
  headers: {'content-type': 'application/json'},
  data: {policyDocument: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/policies/:policyName/version';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"policyDocument":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"policyDocument": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/policies/:policyName/version"]
                                                       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}}/policies/:policyName/version" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"policyDocument\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/policies/:policyName/version",
  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([
    'policyDocument' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/policies/:policyName/version', [
  'body' => '{
  "policyDocument": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/policies/:policyName/version');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'policyDocument' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'policyDocument' => ''
]));
$request->setRequestUrl('{{baseUrl}}/policies/:policyName/version');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/policies/:policyName/version' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policyDocument": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/policies/:policyName/version' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "policyDocument": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"policyDocument\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/policies/:policyName/version", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/policies/:policyName/version"

payload = { "policyDocument": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/policies/:policyName/version"

payload <- "{\n  \"policyDocument\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/policies/:policyName/version")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"policyDocument\": \"\"\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/policies/:policyName/version') do |req|
  req.body = "{\n  \"policyDocument\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/policies/:policyName/version";

    let payload = json!({"policyDocument": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "policyDocument": ""
}' |  \
  http POST {{baseUrl}}/policies/:policyName/version \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "policyDocument": ""\n}' \
  --output-document \
  - {{baseUrl}}/policies/:policyName/version

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["policyDocument": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/policies/:policyName/version")! 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}}/provisioning-templates/:templateName/provisioning-claim");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")

require "http/client"

url = "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/provisioning-templates/:templateName/provisioning-claim HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim';
const options = {method: 'POST'};

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}}/provisioning-templates/:templateName/provisioning-claim',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/provisioning-templates/:templateName/provisioning-claim',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim');

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}}/provisioning-templates/:templateName/provisioning-claim'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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}}/provisioning-templates/:templateName/provisioning-claim" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim');

echo $response->getBody();

setUrl('{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/provisioning-templates/:templateName/provisioning-claim")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/provisioning-templates/:templateName/provisioning-claim') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/provisioning-templates/:templateName/provisioning-claim

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/provisioning-templates/:templateName/provisioning-claim

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/provisioning-templates/:templateName/provisioning-claim")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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}}/provisioning-templates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/provisioning-templates" {:content-type :json
                                                                   :form-params {:templateName ""
                                                                                 :description ""
                                                                                 :templateBody ""
                                                                                 :enabled false
                                                                                 :provisioningRoleArn ""
                                                                                 :preProvisioningHook {:payloadVersion ""
                                                                                                       :targetArn ""}
                                                                                 :tags [{:Key ""
                                                                                         :Value ""}]
                                                                                 :type ""}})

require "http/client"

url = "{{baseUrl}}/provisioning-templates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\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}}/provisioning-templates"),
    Content = new StringContent("{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\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}}/provisioning-templates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/provisioning-templates"

	payload := strings.NewReader("{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/provisioning-templates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 272

{
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": {
    "payloadVersion": "",
    "targetArn": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/provisioning-templates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/provisioning-templates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\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  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/provisioning-templates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/provisioning-templates")
  .header("content-type", "application/json")
  .body("{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  templateName: '',
  description: '',
  templateBody: '',
  enabled: false,
  provisioningRoleArn: '',
  preProvisioningHook: {
    payloadVersion: '',
    targetArn: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/provisioning-templates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates',
  headers: {'content-type': 'application/json'},
  data: {
    templateName: '',
    description: '',
    templateBody: '',
    enabled: false,
    provisioningRoleArn: '',
    preProvisioningHook: {payloadVersion: '', targetArn: ''},
    tags: [{Key: '', Value: ''}],
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/provisioning-templates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"templateName":"","description":"","templateBody":"","enabled":false,"provisioningRoleArn":"","preProvisioningHook":{"payloadVersion":"","targetArn":""},"tags":[{"Key":"","Value":""}],"type":""}'
};

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}}/provisioning-templates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "templateName": "",\n  "description": "",\n  "templateBody": "",\n  "enabled": false,\n  "provisioningRoleArn": "",\n  "preProvisioningHook": {\n    "payloadVersion": "",\n    "targetArn": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/provisioning-templates")
  .post(body)
  .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/provisioning-templates',
  headers: {
    '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({
  templateName: '',
  description: '',
  templateBody: '',
  enabled: false,
  provisioningRoleArn: '',
  preProvisioningHook: {payloadVersion: '', targetArn: ''},
  tags: [{Key: '', Value: ''}],
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates',
  headers: {'content-type': 'application/json'},
  body: {
    templateName: '',
    description: '',
    templateBody: '',
    enabled: false,
    provisioningRoleArn: '',
    preProvisioningHook: {payloadVersion: '', targetArn: ''},
    tags: [{Key: '', Value: ''}],
    type: ''
  },
  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}}/provisioning-templates');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  templateName: '',
  description: '',
  templateBody: '',
  enabled: false,
  provisioningRoleArn: '',
  preProvisioningHook: {
    payloadVersion: '',
    targetArn: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  type: ''
});

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}}/provisioning-templates',
  headers: {'content-type': 'application/json'},
  data: {
    templateName: '',
    description: '',
    templateBody: '',
    enabled: false,
    provisioningRoleArn: '',
    preProvisioningHook: {payloadVersion: '', targetArn: ''},
    tags: [{Key: '', Value: ''}],
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/provisioning-templates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"templateName":"","description":"","templateBody":"","enabled":false,"provisioningRoleArn":"","preProvisioningHook":{"payloadVersion":"","targetArn":""},"tags":[{"Key":"","Value":""}],"type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"templateName": @"",
                              @"description": @"",
                              @"templateBody": @"",
                              @"enabled": @NO,
                              @"provisioningRoleArn": @"",
                              @"preProvisioningHook": @{ @"payloadVersion": @"", @"targetArn": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/provisioning-templates"]
                                                       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}}/provisioning-templates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/provisioning-templates",
  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([
    'templateName' => '',
    'description' => '',
    'templateBody' => '',
    'enabled' => null,
    'provisioningRoleArn' => '',
    'preProvisioningHook' => [
        'payloadVersion' => '',
        'targetArn' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/provisioning-templates', [
  'body' => '{
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": {
    "payloadVersion": "",
    "targetArn": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "type": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/provisioning-templates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'templateName' => '',
  'description' => '',
  'templateBody' => '',
  'enabled' => null,
  'provisioningRoleArn' => '',
  'preProvisioningHook' => [
    'payloadVersion' => '',
    'targetArn' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'templateName' => '',
  'description' => '',
  'templateBody' => '',
  'enabled' => null,
  'provisioningRoleArn' => '',
  'preProvisioningHook' => [
    'payloadVersion' => '',
    'targetArn' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/provisioning-templates');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/provisioning-templates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": {
    "payloadVersion": "",
    "targetArn": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "type": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/provisioning-templates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": {
    "payloadVersion": "",
    "targetArn": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/provisioning-templates", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/provisioning-templates"

payload = {
    "templateName": "",
    "description": "",
    "templateBody": "",
    "enabled": False,
    "provisioningRoleArn": "",
    "preProvisioningHook": {
        "payloadVersion": "",
        "targetArn": ""
    },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "type": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/provisioning-templates"

payload <- "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/provisioning-templates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\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/provisioning-templates') do |req|
  req.body = "{\n  \"templateName\": \"\",\n  \"description\": \"\",\n  \"templateBody\": \"\",\n  \"enabled\": false,\n  \"provisioningRoleArn\": \"\",\n  \"preProvisioningHook\": {\n    \"payloadVersion\": \"\",\n    \"targetArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/provisioning-templates";

    let payload = json!({
        "templateName": "",
        "description": "",
        "templateBody": "",
        "enabled": false,
        "provisioningRoleArn": "",
        "preProvisioningHook": json!({
            "payloadVersion": "",
            "targetArn": ""
        }),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": {
    "payloadVersion": "",
    "targetArn": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "type": ""
}' |  \
  http POST {{baseUrl}}/provisioning-templates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "templateName": "",\n  "description": "",\n  "templateBody": "",\n  "enabled": false,\n  "provisioningRoleArn": "",\n  "preProvisioningHook": {\n    "payloadVersion": "",\n    "targetArn": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/provisioning-templates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "templateName": "",
  "description": "",
  "templateBody": "",
  "enabled": false,
  "provisioningRoleArn": "",
  "preProvisioningHook": [
    "payloadVersion": "",
    "targetArn": ""
  ],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/provisioning-templates")! 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}}/provisioning-templates/:templateName/versions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"templateBody\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/provisioning-templates/:templateName/versions" {:content-type :json
                                                                                          :form-params {:templateBody ""}})

require "http/client"

url = "{{baseUrl}}/provisioning-templates/:templateName/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"templateBody\": \"\"\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}}/provisioning-templates/:templateName/versions"),
    Content = new StringContent("{\n  \"templateBody\": \"\"\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}}/provisioning-templates/:templateName/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"templateBody\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/provisioning-templates/:templateName/versions"

	payload := strings.NewReader("{\n  \"templateBody\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/provisioning-templates/:templateName/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "templateBody": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/provisioning-templates/:templateName/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"templateBody\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/provisioning-templates/:templateName/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"templateBody\": \"\"\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  \"templateBody\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/provisioning-templates/:templateName/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/provisioning-templates/:templateName/versions")
  .header("content-type", "application/json")
  .body("{\n  \"templateBody\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  templateBody: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/provisioning-templates/:templateName/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates/:templateName/versions',
  headers: {'content-type': 'application/json'},
  data: {templateBody: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/provisioning-templates/:templateName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"templateBody":""}'
};

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}}/provisioning-templates/:templateName/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "templateBody": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"templateBody\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/provisioning-templates/:templateName/versions")
  .post(body)
  .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/provisioning-templates/:templateName/versions',
  headers: {
    '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({templateBody: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/provisioning-templates/:templateName/versions',
  headers: {'content-type': 'application/json'},
  body: {templateBody: ''},
  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}}/provisioning-templates/:templateName/versions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  templateBody: ''
});

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}}/provisioning-templates/:templateName/versions',
  headers: {'content-type': 'application/json'},
  data: {templateBody: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/provisioning-templates/:templateName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"templateBody":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"templateBody": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/provisioning-templates/:templateName/versions"]
                                                       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}}/provisioning-templates/:templateName/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"templateBody\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/provisioning-templates/:templateName/versions",
  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([
    'templateBody' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/provisioning-templates/:templateName/versions', [
  'body' => '{
  "templateBody": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/provisioning-templates/:templateName/versions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'templateBody' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'templateBody' => ''
]));
$request->setRequestUrl('{{baseUrl}}/provisioning-templates/:templateName/versions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/provisioning-templates/:templateName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateBody": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/provisioning-templates/:templateName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateBody": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"templateBody\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/provisioning-templates/:templateName/versions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/provisioning-templates/:templateName/versions"

payload = { "templateBody": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/provisioning-templates/:templateName/versions"

payload <- "{\n  \"templateBody\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/provisioning-templates/:templateName/versions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"templateBody\": \"\"\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/provisioning-templates/:templateName/versions') do |req|
  req.body = "{\n  \"templateBody\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/provisioning-templates/:templateName/versions";

    let payload = json!({"templateBody": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "templateBody": ""
}' |  \
  http POST {{baseUrl}}/provisioning-templates/:templateName/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "templateBody": ""\n}' \
  --output-document \
  - {{baseUrl}}/provisioning-templates/:templateName/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["templateBody": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/provisioning-templates/:templateName/versions")! 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}}/role-aliases/:roleAlias");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/role-aliases/:roleAlias" {:content-type :json
                                                                    :form-params {:roleArn ""
                                                                                  :credentialDurationSeconds 0
                                                                                  :tags [{:Key ""
                                                                                          :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/role-aliases/:roleAlias"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/role-aliases/:roleAlias"),
    Content = new StringContent("{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/role-aliases/:roleAlias");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/role-aliases/:roleAlias"

	payload := strings.NewReader("{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/role-aliases/:roleAlias HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 117

{
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/role-aliases/:roleAlias")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/role-aliases/:roleAlias"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/role-aliases/:roleAlias")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/role-aliases/:roleAlias")
  .header("content-type", "application/json")
  .body("{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  roleArn: '',
  credentialDurationSeconds: 0,
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/role-aliases/:roleAlias');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/role-aliases/:roleAlias',
  headers: {'content-type': 'application/json'},
  data: {roleArn: '', credentialDurationSeconds: 0, tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/role-aliases/:roleAlias';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleArn":"","credentialDurationSeconds":0,"tags":[{"Key":"","Value":""}]}'
};

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}}/role-aliases/:roleAlias',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "roleArn": "",\n  "credentialDurationSeconds": 0,\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/role-aliases/:roleAlias")
  .post(body)
  .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/role-aliases/:roleAlias',
  headers: {
    '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({roleArn: '', credentialDurationSeconds: 0, tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/role-aliases/:roleAlias',
  headers: {'content-type': 'application/json'},
  body: {roleArn: '', credentialDurationSeconds: 0, tags: [{Key: '', Value: ''}]},
  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}}/role-aliases/:roleAlias');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  roleArn: '',
  credentialDurationSeconds: 0,
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/role-aliases/:roleAlias',
  headers: {'content-type': 'application/json'},
  data: {roleArn: '', credentialDurationSeconds: 0, tags: [{Key: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/role-aliases/:roleAlias';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"roleArn":"","credentialDurationSeconds":0,"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"roleArn": @"",
                              @"credentialDurationSeconds": @0,
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/role-aliases/:roleAlias"]
                                                       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}}/role-aliases/:roleAlias" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/role-aliases/:roleAlias",
  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([
    'roleArn' => '',
    'credentialDurationSeconds' => 0,
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/role-aliases/:roleAlias', [
  'body' => '{
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/role-aliases/:roleAlias');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'roleArn' => '',
  'credentialDurationSeconds' => 0,
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'roleArn' => '',
  'credentialDurationSeconds' => 0,
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/role-aliases/:roleAlias');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/role-aliases/:roleAlias' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/role-aliases/:roleAlias' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/role-aliases/:roleAlias", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/role-aliases/:roleAlias"

payload = {
    "roleArn": "",
    "credentialDurationSeconds": 0,
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/role-aliases/:roleAlias"

payload <- "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/role-aliases/:roleAlias")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/role-aliases/:roleAlias') do |req|
  req.body = "{\n  \"roleArn\": \"\",\n  \"credentialDurationSeconds\": 0,\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/role-aliases/:roleAlias";

    let payload = json!({
        "roleArn": "",
        "credentialDurationSeconds": 0,
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/role-aliases/:roleAlias \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "roleArn": "",\n  "credentialDurationSeconds": 0,\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/role-aliases/:roleAlias

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "roleArn": "",
  "credentialDurationSeconds": 0,
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/role-aliases/:roleAlias")! 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}}/audit/scheduledaudits/:scheduledAuditName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName" {:content-type :json
                                                                                      :form-params {:frequency ""
                                                                                                    :dayOfMonth ""
                                                                                                    :dayOfWeek ""
                                                                                                    :targetCheckNames []
                                                                                                    :tags [{:Key ""
                                                                                                            :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/audit/scheduledaudits/:scheduledAuditName"),
    Content = new StringContent("{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/audit/scheduledaudits/:scheduledAuditName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"

	payload := strings.NewReader("{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/audit/scheduledaudits/:scheduledAuditName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 150

{
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")
  .header("content-type", "application/json")
  .body("{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  frequency: '',
  dayOfMonth: '',
  dayOfWeek: '',
  targetCheckNames: [],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName',
  headers: {'content-type': 'application/json'},
  data: {
    frequency: '',
    dayOfMonth: '',
    dayOfWeek: '',
    targetCheckNames: [],
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"frequency":"","dayOfMonth":"","dayOfWeek":"","targetCheckNames":[],"tags":[{"Key":"","Value":""}]}'
};

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}}/audit/scheduledaudits/:scheduledAuditName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "frequency": "",\n  "dayOfMonth": "",\n  "dayOfWeek": "",\n  "targetCheckNames": [],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")
  .post(body)
  .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/audit/scheduledaudits/:scheduledAuditName',
  headers: {
    '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({
  frequency: '',
  dayOfMonth: '',
  dayOfWeek: '',
  targetCheckNames: [],
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName',
  headers: {'content-type': 'application/json'},
  body: {
    frequency: '',
    dayOfMonth: '',
    dayOfWeek: '',
    targetCheckNames: [],
    tags: [{Key: '', Value: ''}]
  },
  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}}/audit/scheduledaudits/:scheduledAuditName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  frequency: '',
  dayOfMonth: '',
  dayOfWeek: '',
  targetCheckNames: [],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/audit/scheduledaudits/:scheduledAuditName',
  headers: {'content-type': 'application/json'},
  data: {
    frequency: '',
    dayOfMonth: '',
    dayOfWeek: '',
    targetCheckNames: [],
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"frequency":"","dayOfMonth":"","dayOfWeek":"","targetCheckNames":[],"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"frequency": @"",
                              @"dayOfMonth": @"",
                              @"dayOfWeek": @"",
                              @"targetCheckNames": @[  ],
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"]
                                                       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}}/audit/scheduledaudits/:scheduledAuditName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName",
  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([
    'frequency' => '',
    'dayOfMonth' => '',
    'dayOfWeek' => '',
    'targetCheckNames' => [
        
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName', [
  'body' => '{
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'frequency' => '',
  'dayOfMonth' => '',
  'dayOfWeek' => '',
  'targetCheckNames' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'frequency' => '',
  'dayOfMonth' => '',
  'dayOfWeek' => '',
  'targetCheckNames' => [
    
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/audit/scheduledaudits/:scheduledAuditName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"

payload = {
    "frequency": "",
    "dayOfMonth": "",
    "dayOfWeek": "",
    "targetCheckNames": [],
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName"

payload <- "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/audit/scheduledaudits/:scheduledAuditName') do |req|
  req.body = "{\n  \"frequency\": \"\",\n  \"dayOfMonth\": \"\",\n  \"dayOfWeek\": \"\",\n  \"targetCheckNames\": [],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName";

    let payload = json!({
        "frequency": "",
        "dayOfMonth": "",
        "dayOfWeek": "",
        "targetCheckNames": (),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/audit/scheduledaudits/:scheduledAuditName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "frequency": "",\n  "dayOfMonth": "",\n  "dayOfWeek": "",\n  "targetCheckNames": [],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/audit/scheduledaudits/:scheduledAuditName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "frequency": "",
  "dayOfMonth": "",
  "dayOfWeek": "",
  "targetCheckNames": [],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/scheduledaudits/:scheduledAuditName")! 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}}/security-profiles/:securityProfileName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/security-profiles/:securityProfileName" {:content-type :json
                                                                                   :form-params {:securityProfileDescription ""
                                                                                                 :behaviors [{:name ""
                                                                                                              :metric ""
                                                                                                              :metricDimension ""
                                                                                                              :criteria ""
                                                                                                              :suppressAlerts ""}]
                                                                                                 :alertTargets {}
                                                                                                 :additionalMetricsToRetain []
                                                                                                 :additionalMetricsToRetainV2 [{:metric ""
                                                                                                                                :metricDimension ""}]
                                                                                                 :tags [{:Key ""
                                                                                                         :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/security-profiles/:securityProfileName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/security-profiles/:securityProfileName"),
    Content = new StringContent("{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/security-profiles/:securityProfileName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/security-profiles/:securityProfileName"

	payload := strings.NewReader("{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/security-profiles/:securityProfileName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 409

{
  "securityProfileDescription": "",
  "behaviors": [
    {
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    }
  ],
  "alertTargets": {},
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    {
      "metric": "",
      "metricDimension": ""
    }
  ],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/security-profiles/:securityProfileName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/security-profiles/:securityProfileName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/security-profiles/:securityProfileName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/security-profiles/:securityProfileName")
  .header("content-type", "application/json")
  .body("{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  securityProfileDescription: '',
  behaviors: [
    {
      name: '',
      metric: '',
      metricDimension: '',
      criteria: '',
      suppressAlerts: ''
    }
  ],
  alertTargets: {},
  additionalMetricsToRetain: [],
  additionalMetricsToRetainV2: [
    {
      metric: '',
      metricDimension: ''
    }
  ],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/security-profiles/:securityProfileName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/security-profiles/:securityProfileName',
  headers: {'content-type': 'application/json'},
  data: {
    securityProfileDescription: '',
    behaviors: [{name: '', metric: '', metricDimension: '', criteria: '', suppressAlerts: ''}],
    alertTargets: {},
    additionalMetricsToRetain: [],
    additionalMetricsToRetainV2: [{metric: '', metricDimension: ''}],
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/security-profiles/:securityProfileName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"securityProfileDescription":"","behaviors":[{"name":"","metric":"","metricDimension":"","criteria":"","suppressAlerts":""}],"alertTargets":{},"additionalMetricsToRetain":[],"additionalMetricsToRetainV2":[{"metric":"","metricDimension":""}],"tags":[{"Key":"","Value":""}]}'
};

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}}/security-profiles/:securityProfileName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "securityProfileDescription": "",\n  "behaviors": [\n    {\n      "name": "",\n      "metric": "",\n      "metricDimension": "",\n      "criteria": "",\n      "suppressAlerts": ""\n    }\n  ],\n  "alertTargets": {},\n  "additionalMetricsToRetain": [],\n  "additionalMetricsToRetainV2": [\n    {\n      "metric": "",\n      "metricDimension": ""\n    }\n  ],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/security-profiles/:securityProfileName")
  .post(body)
  .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/security-profiles/:securityProfileName',
  headers: {
    '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({
  securityProfileDescription: '',
  behaviors: [{name: '', metric: '', metricDimension: '', criteria: '', suppressAlerts: ''}],
  alertTargets: {},
  additionalMetricsToRetain: [],
  additionalMetricsToRetainV2: [{metric: '', metricDimension: ''}],
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/security-profiles/:securityProfileName',
  headers: {'content-type': 'application/json'},
  body: {
    securityProfileDescription: '',
    behaviors: [{name: '', metric: '', metricDimension: '', criteria: '', suppressAlerts: ''}],
    alertTargets: {},
    additionalMetricsToRetain: [],
    additionalMetricsToRetainV2: [{metric: '', metricDimension: ''}],
    tags: [{Key: '', Value: ''}]
  },
  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}}/security-profiles/:securityProfileName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  securityProfileDescription: '',
  behaviors: [
    {
      name: '',
      metric: '',
      metricDimension: '',
      criteria: '',
      suppressAlerts: ''
    }
  ],
  alertTargets: {},
  additionalMetricsToRetain: [],
  additionalMetricsToRetainV2: [
    {
      metric: '',
      metricDimension: ''
    }
  ],
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/security-profiles/:securityProfileName',
  headers: {'content-type': 'application/json'},
  data: {
    securityProfileDescription: '',
    behaviors: [{name: '', metric: '', metricDimension: '', criteria: '', suppressAlerts: ''}],
    alertTargets: {},
    additionalMetricsToRetain: [],
    additionalMetricsToRetainV2: [{metric: '', metricDimension: ''}],
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/security-profiles/:securityProfileName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"securityProfileDescription":"","behaviors":[{"name":"","metric":"","metricDimension":"","criteria":"","suppressAlerts":""}],"alertTargets":{},"additionalMetricsToRetain":[],"additionalMetricsToRetainV2":[{"metric":"","metricDimension":""}],"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"securityProfileDescription": @"",
                              @"behaviors": @[ @{ @"name": @"", @"metric": @"", @"metricDimension": @"", @"criteria": @"", @"suppressAlerts": @"" } ],
                              @"alertTargets": @{  },
                              @"additionalMetricsToRetain": @[  ],
                              @"additionalMetricsToRetainV2": @[ @{ @"metric": @"", @"metricDimension": @"" } ],
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/security-profiles/:securityProfileName"]
                                                       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}}/security-profiles/:securityProfileName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/security-profiles/:securityProfileName",
  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([
    'securityProfileDescription' => '',
    'behaviors' => [
        [
                'name' => '',
                'metric' => '',
                'metricDimension' => '',
                'criteria' => '',
                'suppressAlerts' => ''
        ]
    ],
    'alertTargets' => [
        
    ],
    'additionalMetricsToRetain' => [
        
    ],
    'additionalMetricsToRetainV2' => [
        [
                'metric' => '',
                'metricDimension' => ''
        ]
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/security-profiles/:securityProfileName', [
  'body' => '{
  "securityProfileDescription": "",
  "behaviors": [
    {
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    }
  ],
  "alertTargets": {},
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    {
      "metric": "",
      "metricDimension": ""
    }
  ],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/security-profiles/:securityProfileName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'securityProfileDescription' => '',
  'behaviors' => [
    [
        'name' => '',
        'metric' => '',
        'metricDimension' => '',
        'criteria' => '',
        'suppressAlerts' => ''
    ]
  ],
  'alertTargets' => [
    
  ],
  'additionalMetricsToRetain' => [
    
  ],
  'additionalMetricsToRetainV2' => [
    [
        'metric' => '',
        'metricDimension' => ''
    ]
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'securityProfileDescription' => '',
  'behaviors' => [
    [
        'name' => '',
        'metric' => '',
        'metricDimension' => '',
        'criteria' => '',
        'suppressAlerts' => ''
    ]
  ],
  'alertTargets' => [
    
  ],
  'additionalMetricsToRetain' => [
    
  ],
  'additionalMetricsToRetainV2' => [
    [
        'metric' => '',
        'metricDimension' => ''
    ]
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/security-profiles/:securityProfileName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/security-profiles/:securityProfileName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "securityProfileDescription": "",
  "behaviors": [
    {
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    }
  ],
  "alertTargets": {},
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    {
      "metric": "",
      "metricDimension": ""
    }
  ],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/security-profiles/:securityProfileName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "securityProfileDescription": "",
  "behaviors": [
    {
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    }
  ],
  "alertTargets": {},
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    {
      "metric": "",
      "metricDimension": ""
    }
  ],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/security-profiles/:securityProfileName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/security-profiles/:securityProfileName"

payload = {
    "securityProfileDescription": "",
    "behaviors": [
        {
            "name": "",
            "metric": "",
            "metricDimension": "",
            "criteria": "",
            "suppressAlerts": ""
        }
    ],
    "alertTargets": {},
    "additionalMetricsToRetain": [],
    "additionalMetricsToRetainV2": [
        {
            "metric": "",
            "metricDimension": ""
        }
    ],
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/security-profiles/:securityProfileName"

payload <- "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/security-profiles/:securityProfileName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/security-profiles/:securityProfileName') do |req|
  req.body = "{\n  \"securityProfileDescription\": \"\",\n  \"behaviors\": [\n    {\n      \"name\": \"\",\n      \"metric\": \"\",\n      \"metricDimension\": \"\",\n      \"criteria\": \"\",\n      \"suppressAlerts\": \"\"\n    }\n  ],\n  \"alertTargets\": {},\n  \"additionalMetricsToRetain\": [],\n  \"additionalMetricsToRetainV2\": [\n    {\n      \"metric\": \"\",\n      \"metricDimension\": \"\"\n    }\n  ],\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/security-profiles/:securityProfileName";

    let payload = json!({
        "securityProfileDescription": "",
        "behaviors": (
            json!({
                "name": "",
                "metric": "",
                "metricDimension": "",
                "criteria": "",
                "suppressAlerts": ""
            })
        ),
        "alertTargets": json!({}),
        "additionalMetricsToRetain": (),
        "additionalMetricsToRetainV2": (
            json!({
                "metric": "",
                "metricDimension": ""
            })
        ),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "securityProfileDescription": "",
  "behaviors": [
    {
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    }
  ],
  "alertTargets": {},
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    {
      "metric": "",
      "metricDimension": ""
    }
  ],
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/security-profiles/:securityProfileName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "securityProfileDescription": "",\n  "behaviors": [\n    {\n      "name": "",\n      "metric": "",\n      "metricDimension": "",\n      "criteria": "",\n      "suppressAlerts": ""\n    }\n  ],\n  "alertTargets": {},\n  "additionalMetricsToRetain": [],\n  "additionalMetricsToRetainV2": [\n    {\n      "metric": "",\n      "metricDimension": ""\n    }\n  ],\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/security-profiles/:securityProfileName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "securityProfileDescription": "",
  "behaviors": [
    [
      "name": "",
      "metric": "",
      "metricDimension": "",
      "criteria": "",
      "suppressAlerts": ""
    ]
  ],
  "alertTargets": [],
  "additionalMetricsToRetain": [],
  "additionalMetricsToRetainV2": [
    [
      "metric": "",
      "metricDimension": ""
    ]
  ],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/security-profiles/:securityProfileName")! 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}}/streams/:streamId");

struct curl_slist *headers = NULL;
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  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/streams/:streamId" {:content-type :json
                                                              :form-params {:description ""
                                                                            :files [{:fileId ""
                                                                                     :s3Location ""}]
                                                                            :roleArn ""
                                                                            :tags [{:Key ""
                                                                                    :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/streams/:streamId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/streams/:streamId"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/streams/:streamId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/streams/:streamId"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/streams/:streamId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 177

{
  "description": "",
  "files": [
    {
      "fileId": "",
      "s3Location": ""
    }
  ],
  "roleArn": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/streams/:streamId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/streams/:streamId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/streams/:streamId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/streams/:streamId")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  files: [
    {
      fileId: '',
      s3Location: ''
    }
  ],
  roleArn: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/streams/:streamId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/streams/:streamId',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    files: [{fileId: '', s3Location: ''}],
    roleArn: '',
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/streams/:streamId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","files":[{"fileId":"","s3Location":""}],"roleArn":"","tags":[{"Key":"","Value":""}]}'
};

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}}/streams/:streamId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "files": [\n    {\n      "fileId": "",\n      "s3Location": ""\n    }\n  ],\n  "roleArn": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/streams/:streamId")
  .post(body)
  .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/streams/:streamId',
  headers: {
    '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: '',
  files: [{fileId: '', s3Location: ''}],
  roleArn: '',
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/streams/:streamId',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    files: [{fileId: '', s3Location: ''}],
    roleArn: '',
    tags: [{Key: '', Value: ''}]
  },
  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}}/streams/:streamId');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  files: [
    {
      fileId: '',
      s3Location: ''
    }
  ],
  roleArn: '',
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/streams/:streamId',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    files: [{fileId: '', s3Location: ''}],
    roleArn: '',
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/streams/:streamId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","files":[{"fileId":"","s3Location":""}],"roleArn":"","tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"files": @[ @{ @"fileId": @"", @"s3Location": @"" } ],
                              @"roleArn": @"",
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/streams/:streamId"]
                                                       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}}/streams/:streamId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/streams/:streamId",
  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' => '',
    'files' => [
        [
                'fileId' => '',
                's3Location' => ''
        ]
    ],
    'roleArn' => '',
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/streams/:streamId', [
  'body' => '{
  "description": "",
  "files": [
    {
      "fileId": "",
      "s3Location": ""
    }
  ],
  "roleArn": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/streams/:streamId');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'files' => [
    [
        'fileId' => '',
        's3Location' => ''
    ]
  ],
  'roleArn' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'files' => [
    [
        'fileId' => '',
        's3Location' => ''
    ]
  ],
  'roleArn' => '',
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/streams/:streamId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/streams/:streamId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "files": [
    {
      "fileId": "",
      "s3Location": ""
    }
  ],
  "roleArn": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/streams/:streamId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "files": [
    {
      "fileId": "",
      "s3Location": ""
    }
  ],
  "roleArn": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/streams/:streamId", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/streams/:streamId"

payload = {
    "description": "",
    "files": [
        {
            "fileId": "",
            "s3Location": ""
        }
    ],
    "roleArn": "",
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/streams/:streamId"

payload <- "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/streams/:streamId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/streams/:streamId') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"files\": [\n    {\n      \"fileId\": \"\",\n      \"s3Location\": \"\"\n    }\n  ],\n  \"roleArn\": \"\",\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/streams/:streamId";

    let payload = json!({
        "description": "",
        "files": (
            json!({
                "fileId": "",
                "s3Location": ""
            })
        ),
        "roleArn": "",
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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": "",
  "files": [
    {
      "fileId": "",
      "s3Location": ""
    }
  ],
  "roleArn": "",
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/streams/:streamId \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "files": [\n    {\n      "fileId": "",\n      "s3Location": ""\n    }\n  ],\n  "roleArn": "",\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/streams/:streamId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "files": [
    [
      "fileId": "",
      "s3Location": ""
    ]
  ],
  "roleArn": "",
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/streams/:streamId")! 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}}/things/:thingName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/things/:thingName" {:content-type :json
                                                              :form-params {:thingTypeName ""
                                                                            :attributePayload {:attributes ""
                                                                                               :merge ""}
                                                                            :billingGroupName ""}})

require "http/client"

url = "{{baseUrl}}/things/:thingName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\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}}/things/:thingName"),
    Content = new StringContent("{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\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}}/things/:thingName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/things/:thingName"

	payload := strings.NewReader("{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/things/:thingName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 118

{
  "thingTypeName": "",
  "attributePayload": {
    "attributes": "",
    "merge": ""
  },
  "billingGroupName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/things/:thingName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/things/:thingName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\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  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/things/:thingName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/things/:thingName")
  .header("content-type", "application/json")
  .body("{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  thingTypeName: '',
  attributePayload: {
    attributes: '',
    merge: ''
  },
  billingGroupName: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/things/:thingName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/things/:thingName',
  headers: {'content-type': 'application/json'},
  data: {
    thingTypeName: '',
    attributePayload: {attributes: '', merge: ''},
    billingGroupName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/things/:thingName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingTypeName":"","attributePayload":{"attributes":"","merge":""},"billingGroupName":""}'
};

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}}/things/:thingName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "thingTypeName": "",\n  "attributePayload": {\n    "attributes": "",\n    "merge": ""\n  },\n  "billingGroupName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/things/:thingName")
  .post(body)
  .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/things/:thingName',
  headers: {
    '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({
  thingTypeName: '',
  attributePayload: {attributes: '', merge: ''},
  billingGroupName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/things/:thingName',
  headers: {'content-type': 'application/json'},
  body: {
    thingTypeName: '',
    attributePayload: {attributes: '', merge: ''},
    billingGroupName: ''
  },
  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}}/things/:thingName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  thingTypeName: '',
  attributePayload: {
    attributes: '',
    merge: ''
  },
  billingGroupName: ''
});

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}}/things/:thingName',
  headers: {'content-type': 'application/json'},
  data: {
    thingTypeName: '',
    attributePayload: {attributes: '', merge: ''},
    billingGroupName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/things/:thingName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingTypeName":"","attributePayload":{"attributes":"","merge":""},"billingGroupName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"thingTypeName": @"",
                              @"attributePayload": @{ @"attributes": @"", @"merge": @"" },
                              @"billingGroupName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/things/:thingName"]
                                                       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}}/things/:thingName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/things/:thingName",
  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([
    'thingTypeName' => '',
    'attributePayload' => [
        'attributes' => '',
        'merge' => ''
    ],
    'billingGroupName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/things/:thingName', [
  'body' => '{
  "thingTypeName": "",
  "attributePayload": {
    "attributes": "",
    "merge": ""
  },
  "billingGroupName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/things/:thingName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'thingTypeName' => '',
  'attributePayload' => [
    'attributes' => '',
    'merge' => ''
  ],
  'billingGroupName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'thingTypeName' => '',
  'attributePayload' => [
    'attributes' => '',
    'merge' => ''
  ],
  'billingGroupName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/things/:thingName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/things/:thingName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingTypeName": "",
  "attributePayload": {
    "attributes": "",
    "merge": ""
  },
  "billingGroupName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/things/:thingName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingTypeName": "",
  "attributePayload": {
    "attributes": "",
    "merge": ""
  },
  "billingGroupName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/things/:thingName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/things/:thingName"

payload = {
    "thingTypeName": "",
    "attributePayload": {
        "attributes": "",
        "merge": ""
    },
    "billingGroupName": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/things/:thingName"

payload <- "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/things/:thingName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\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/things/:thingName') do |req|
  req.body = "{\n  \"thingTypeName\": \"\",\n  \"attributePayload\": {\n    \"attributes\": \"\",\n    \"merge\": \"\"\n  },\n  \"billingGroupName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/things/:thingName";

    let payload = json!({
        "thingTypeName": "",
        "attributePayload": json!({
            "attributes": "",
            "merge": ""
        }),
        "billingGroupName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "thingTypeName": "",
  "attributePayload": {
    "attributes": "",
    "merge": ""
  },
  "billingGroupName": ""
}' |  \
  http POST {{baseUrl}}/things/:thingName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "thingTypeName": "",\n  "attributePayload": {\n    "attributes": "",\n    "merge": ""\n  },\n  "billingGroupName": ""\n}' \
  --output-document \
  - {{baseUrl}}/things/:thingName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "thingTypeName": "",
  "attributePayload": [
    "attributes": "",
    "merge": ""
  ],
  "billingGroupName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/things/:thingName")! 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}}/thing-groups/:thingGroupName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/thing-groups/:thingGroupName" {:content-type :json
                                                                         :form-params {:parentGroupName ""
                                                                                       :thingGroupProperties {:thingGroupDescription ""
                                                                                                              :attributePayload ""}
                                                                                       :tags [{:Key ""
                                                                                               :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/thing-groups/:thingGroupName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/thing-groups/:thingGroupName"),
    Content = new StringContent("{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/thing-groups/:thingGroupName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/thing-groups/:thingGroupName"

	payload := strings.NewReader("{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/thing-groups/:thingGroupName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 184

{
  "parentGroupName": "",
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/thing-groups/:thingGroupName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/thing-groups/:thingGroupName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/thing-groups/:thingGroupName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/thing-groups/:thingGroupName")
  .header("content-type", "application/json")
  .body("{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  parentGroupName: '',
  thingGroupProperties: {
    thingGroupDescription: '',
    attributePayload: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/thing-groups/:thingGroupName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    parentGroupName: '',
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/thing-groups/:thingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"parentGroupName":"","thingGroupProperties":{"thingGroupDescription":"","attributePayload":""},"tags":[{"Key":"","Value":""}]}'
};

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}}/thing-groups/:thingGroupName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "parentGroupName": "",\n  "thingGroupProperties": {\n    "thingGroupDescription": "",\n    "attributePayload": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/thing-groups/:thingGroupName")
  .post(body)
  .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/thing-groups/:thingGroupName',
  headers: {
    '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({
  parentGroupName: '',
  thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  body: {
    parentGroupName: '',
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    tags: [{Key: '', Value: ''}]
  },
  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}}/thing-groups/:thingGroupName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  parentGroupName: '',
  thingGroupProperties: {
    thingGroupDescription: '',
    attributePayload: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/thing-groups/:thingGroupName',
  headers: {'content-type': 'application/json'},
  data: {
    parentGroupName: '',
    thingGroupProperties: {thingGroupDescription: '', attributePayload: ''},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/thing-groups/:thingGroupName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"parentGroupName":"","thingGroupProperties":{"thingGroupDescription":"","attributePayload":""},"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"parentGroupName": @"",
                              @"thingGroupProperties": @{ @"thingGroupDescription": @"", @"attributePayload": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/thing-groups/:thingGroupName"]
                                                       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}}/thing-groups/:thingGroupName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/thing-groups/:thingGroupName",
  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([
    'parentGroupName' => '',
    'thingGroupProperties' => [
        'thingGroupDescription' => '',
        'attributePayload' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/thing-groups/:thingGroupName', [
  'body' => '{
  "parentGroupName": "",
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/thing-groups/:thingGroupName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'parentGroupName' => '',
  'thingGroupProperties' => [
    'thingGroupDescription' => '',
    'attributePayload' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'parentGroupName' => '',
  'thingGroupProperties' => [
    'thingGroupDescription' => '',
    'attributePayload' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/thing-groups/:thingGroupName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/thing-groups/:thingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentGroupName": "",
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/thing-groups/:thingGroupName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "parentGroupName": "",
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/thing-groups/:thingGroupName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/thing-groups/:thingGroupName"

payload = {
    "parentGroupName": "",
    "thingGroupProperties": {
        "thingGroupDescription": "",
        "attributePayload": ""
    },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/thing-groups/:thingGroupName"

payload <- "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/thing-groups/:thingGroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/thing-groups/:thingGroupName') do |req|
  req.body = "{\n  \"parentGroupName\": \"\",\n  \"thingGroupProperties\": {\n    \"thingGroupDescription\": \"\",\n    \"attributePayload\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/thing-groups/:thingGroupName";

    let payload = json!({
        "parentGroupName": "",
        "thingGroupProperties": json!({
            "thingGroupDescription": "",
            "attributePayload": ""
        }),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "parentGroupName": "",
  "thingGroupProperties": {
    "thingGroupDescription": "",
    "attributePayload": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/thing-groups/:thingGroupName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "parentGroupName": "",\n  "thingGroupProperties": {\n    "thingGroupDescription": "",\n    "attributePayload": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/thing-groups/:thingGroupName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "parentGroupName": "",
  "thingGroupProperties": [
    "thingGroupDescription": "",
    "attributePayload": ""
  ],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/thing-groups/:thingGroupName")! 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}}/thing-types/:thingTypeName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/thing-types/:thingTypeName" {:content-type :json
                                                                       :form-params {:thingTypeProperties {:thingTypeDescription ""
                                                                                                           :searchableAttributes ""}
                                                                                     :tags [{:Key ""
                                                                                             :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/thing-types/:thingTypeName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/thing-types/:thingTypeName"),
    Content = new StringContent("{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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}}/thing-types/:thingTypeName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/thing-types/:thingTypeName"

	payload := strings.NewReader("{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/thing-types/:thingTypeName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 161

{
  "thingTypeProperties": {
    "thingTypeDescription": "",
    "searchableAttributes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/thing-types/:thingTypeName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/thing-types/:thingTypeName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/thing-types/:thingTypeName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/thing-types/:thingTypeName")
  .header("content-type", "application/json")
  .body("{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  thingTypeProperties: {
    thingTypeDescription: '',
    searchableAttributes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/thing-types/:thingTypeName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/thing-types/:thingTypeName',
  headers: {'content-type': 'application/json'},
  data: {
    thingTypeProperties: {thingTypeDescription: '', searchableAttributes: ''},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/thing-types/:thingTypeName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingTypeProperties":{"thingTypeDescription":"","searchableAttributes":""},"tags":[{"Key":"","Value":""}]}'
};

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}}/thing-types/:thingTypeName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "thingTypeProperties": {\n    "thingTypeDescription": "",\n    "searchableAttributes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\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  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/thing-types/:thingTypeName")
  .post(body)
  .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/thing-types/:thingTypeName',
  headers: {
    '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({
  thingTypeProperties: {thingTypeDescription: '', searchableAttributes: ''},
  tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/thing-types/:thingTypeName',
  headers: {'content-type': 'application/json'},
  body: {
    thingTypeProperties: {thingTypeDescription: '', searchableAttributes: ''},
    tags: [{Key: '', Value: ''}]
  },
  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}}/thing-types/:thingTypeName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  thingTypeProperties: {
    thingTypeDescription: '',
    searchableAttributes: ''
  },
  tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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}}/thing-types/:thingTypeName',
  headers: {'content-type': 'application/json'},
  data: {
    thingTypeProperties: {thingTypeDescription: '', searchableAttributes: ''},
    tags: [{Key: '', Value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/thing-types/:thingTypeName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"thingTypeProperties":{"thingTypeDescription":"","searchableAttributes":""},"tags":[{"Key":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"thingTypeProperties": @{ @"thingTypeDescription": @"", @"searchableAttributes": @"" },
                              @"tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/thing-types/:thingTypeName"]
                                                       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}}/thing-types/:thingTypeName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/thing-types/:thingTypeName",
  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([
    'thingTypeProperties' => [
        'thingTypeDescription' => '',
        'searchableAttributes' => ''
    ],
    'tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/thing-types/:thingTypeName', [
  'body' => '{
  "thingTypeProperties": {
    "thingTypeDescription": "",
    "searchableAttributes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/thing-types/:thingTypeName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'thingTypeProperties' => [
    'thingTypeDescription' => '',
    'searchableAttributes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'thingTypeProperties' => [
    'thingTypeDescription' => '',
    'searchableAttributes' => ''
  ],
  'tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/thing-types/:thingTypeName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/thing-types/:thingTypeName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingTypeProperties": {
    "thingTypeDescription": "",
    "searchableAttributes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/thing-types/:thingTypeName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "thingTypeProperties": {
    "thingTypeDescription": "",
    "searchableAttributes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/thing-types/:thingTypeName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/thing-types/:thingTypeName"

payload = {
    "thingTypeProperties": {
        "thingTypeDescription": "",
        "searchableAttributes": ""
    },
    "tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/thing-types/:thingTypeName"

payload <- "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/thing-types/:thingTypeName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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/thing-types/:thingTypeName') do |req|
  req.body = "{\n  \"thingTypeProperties\": {\n    \"thingTypeDescription\": \"\",\n    \"searchableAttributes\": \"\"\n  },\n  \"tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/thing-types/:thingTypeName";

    let payload = json!({
        "thingTypeProperties": json!({
            "thingTypeDescription": "",
            "searchableAttributes": ""
        }),
        "tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "thingTypeProperties": {
    "thingTypeDescription": "",
    "searchableAttributes": ""
  },
  "tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/thing-types/:thingTypeName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "thingTypeProperties": {\n    "thingTypeDescription": "",\n    "searchableAttributes": ""\n  },\n  "tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/thing-types/:thingTypeName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "thingTypeProperties": [
    "thingTypeDescription": "",
    "searchableAttributes": ""
  ],
  "tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/thing-types/:thingTypeName")! 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}}/rules/:ruleName");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/rules/:ruleName" {:content-type :json
                                                            :form-params {:topicRulePayload {:sql ""
                                                                                             :description ""
                                                                                             :actions ""
                                                                                             :ruleDisabled ""
                                                                                             :awsIotSqlVersion ""
                                                                                             :errorAction ""}}})

require "http/client"

url = "{{baseUrl}}/rules/:ruleName"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\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}}/rules/:ruleName"),
    Content = new StringContent("{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\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}}/rules/:ruleName");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/rules/:ruleName"

	payload := strings.NewReader("{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/rules/:ruleName HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 162

{
  "topicRulePayload": {
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/rules/:ruleName")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/rules/:ruleName"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\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  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/rules/:ruleName")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/rules/:ruleName")
  .header("content-type", "application/json")
  .body("{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  topicRulePayload: {
    sql: '',
    description: '',
    actions: '',
    ruleDisabled: '',
    awsIotSqlVersion: '',
    errorAction: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/rules/:ruleName');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rules/:ruleName',
  headers: {'content-type': 'application/json'},
  data: {
    topicRulePayload: {
      sql: '',
      description: '',
      actions: '',
      ruleDisabled: '',
      awsIotSqlVersion: '',
      errorAction: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/rules/:ruleName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"topicRulePayload":{"sql":"","description":"","actions":"","ruleDisabled":"","awsIotSqlVersion":"","errorAction":""}}'
};

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}}/rules/:ruleName',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "topicRulePayload": {\n    "sql": "",\n    "description": "",\n    "actions": "",\n    "ruleDisabled": "",\n    "awsIotSqlVersion": "",\n    "errorAction": ""\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  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/rules/:ruleName")
  .post(body)
  .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/rules/:ruleName',
  headers: {
    '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({
  topicRulePayload: {
    sql: '',
    description: '',
    actions: '',
    ruleDisabled: '',
    awsIotSqlVersion: '',
    errorAction: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/rules/:ruleName',
  headers: {'content-type': 'application/json'},
  body: {
    topicRulePayload: {
      sql: '',
      description: '',
      actions: '',
      ruleDisabled: '',
      awsIotSqlVersion: '',
      errorAction: ''
    }
  },
  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}}/rules/:ruleName');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  topicRulePayload: {
    sql: '',
    description: '',
    actions: '',
    ruleDisabled: '',
    awsIotSqlVersion: '',
    errorAction: ''
  }
});

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}}/rules/:ruleName',
  headers: {'content-type': 'application/json'},
  data: {
    topicRulePayload: {
      sql: '',
      description: '',
      actions: '',
      ruleDisabled: '',
      awsIotSqlVersion: '',
      errorAction: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/rules/:ruleName';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"topicRulePayload":{"sql":"","description":"","actions":"","ruleDisabled":"","awsIotSqlVersion":"","errorAction":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"topicRulePayload": @{ @"sql": @"", @"description": @"", @"actions": @"", @"ruleDisabled": @"", @"awsIotSqlVersion": @"", @"errorAction": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/rules/:ruleName"]
                                                       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}}/rules/:ruleName" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/rules/:ruleName",
  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([
    'topicRulePayload' => [
        'sql' => '',
        'description' => '',
        'actions' => '',
        'ruleDisabled' => '',
        'awsIotSqlVersion' => '',
        'errorAction' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/rules/:ruleName', [
  'body' => '{
  "topicRulePayload": {
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/rules/:ruleName');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'topicRulePayload' => [
    'sql' => '',
    'description' => '',
    'actions' => '',
    'ruleDisabled' => '',
    'awsIotSqlVersion' => '',
    'errorAction' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'topicRulePayload' => [
    'sql' => '',
    'description' => '',
    'actions' => '',
    'ruleDisabled' => '',
    'awsIotSqlVersion' => '',
    'errorAction' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/rules/:ruleName');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/rules/:ruleName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "topicRulePayload": {
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/rules/:ruleName' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "topicRulePayload": {
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/rules/:ruleName", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/rules/:ruleName"

payload = { "topicRulePayload": {
        "sql": "",
        "description": "",
        "actions": "",
        "ruleDisabled": "",
        "awsIotSqlVersion": "",
        "errorAction": ""
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/rules/:ruleName"

payload <- "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/rules/:ruleName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\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/rules/:ruleName') do |req|
  req.body = "{\n  \"topicRulePayload\": {\n    \"sql\": \"\",\n    \"description\": \"\",\n    \"actions\": \"\",\n    \"ruleDisabled\": \"\",\n    \"awsIotSqlVersion\": \"\",\n    \"errorAction\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/rules/:ruleName";

    let payload = json!({"topicRulePayload": json!({
            "sql": "",
            "description": "",
            "actions": "",
            "ruleDisabled": "",
            "awsIotSqlVersion": "",
            "errorAction": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "topicRulePayload": {
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  }
}' |  \
  http POST {{baseUrl}}/rules/:ruleName \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "topicRulePayload": {\n    "sql": "",\n    "description": "",\n    "actions": "",\n    "ruleDisabled": "",\n    "awsIotSqlVersion": "",\n    "errorAction": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/rules/:ruleName

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["topicRulePayload": [
    "sql": "",
    "description": "",
    "actions": "",
    "ruleDisabled": "",
    "awsIotSqlVersion": "",
    "errorAction": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/rules/:ruleName")! 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}}/destinations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/destinations" {:content-type :json
                                                         :form-params {:destinationConfiguration {:httpUrlConfiguration ""
                                                                                                  :vpcConfiguration ""}}})

require "http/client"

url = "{{baseUrl}}/destinations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\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}}/destinations"),
    Content = new StringContent("{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\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}}/destinations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/destinations"

	payload := strings.NewReader("{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/destinations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "destinationConfiguration": {
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/destinations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/destinations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\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  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/destinations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/destinations")
  .header("content-type", "application/json")
  .body("{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  destinationConfiguration: {
    httpUrlConfiguration: '',
    vpcConfiguration: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/destinations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/destinations',
  headers: {'content-type': 'application/json'},
  data: {destinationConfiguration: {httpUrlConfiguration: '', vpcConfiguration: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/destinations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"destinationConfiguration":{"httpUrlConfiguration":"","vpcConfiguration":""}}'
};

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}}/destinations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "destinationConfiguration": {\n    "httpUrlConfiguration": "",\n    "vpcConfiguration": ""\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  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/destinations")
  .post(body)
  .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/destinations',
  headers: {
    '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({destinationConfiguration: {httpUrlConfiguration: '', vpcConfiguration: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/destinations',
  headers: {'content-type': 'application/json'},
  body: {destinationConfiguration: {httpUrlConfiguration: '', vpcConfiguration: ''}},
  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}}/destinations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  destinationConfiguration: {
    httpUrlConfiguration: '',
    vpcConfiguration: ''
  }
});

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}}/destinations',
  headers: {'content-type': 'application/json'},
  data: {destinationConfiguration: {httpUrlConfiguration: '', vpcConfiguration: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/destinations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"destinationConfiguration":{"httpUrlConfiguration":"","vpcConfiguration":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"destinationConfiguration": @{ @"httpUrlConfiguration": @"", @"vpcConfiguration": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/destinations"]
                                                       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}}/destinations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/destinations",
  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([
    'destinationConfiguration' => [
        'httpUrlConfiguration' => '',
        'vpcConfiguration' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/destinations', [
  'body' => '{
  "destinationConfiguration": {
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/destinations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'destinationConfiguration' => [
    'httpUrlConfiguration' => '',
    'vpcConfiguration' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'destinationConfiguration' => [
    'httpUrlConfiguration' => '',
    'vpcConfiguration' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/destinations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/destinations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destinationConfiguration": {
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/destinations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "destinationConfiguration": {
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/destinations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/destinations"

payload = { "destinationConfiguration": {
        "httpUrlConfiguration": "",
        "vpcConfiguration": ""
    } }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/destinations"

payload <- "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/destinations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\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/destinations') do |req|
  req.body = "{\n  \"destinationConfiguration\": {\n    \"httpUrlConfiguration\": \"\",\n    \"vpcConfiguration\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/destinations";

    let payload = json!({"destinationConfiguration": json!({
            "httpUrlConfiguration": "",
            "vpcConfiguration": ""
        })});

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "destinationConfiguration": {
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  }
}' |  \
  http POST {{baseUrl}}/destinations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "destinationConfiguration": {\n    "httpUrlConfiguration": "",\n    "vpcConfiguration": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/destinations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["destinationConfiguration": [
    "httpUrlConfiguration": "",
    "vpcConfiguration": ""
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/destinations")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/audit/configuration");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/audit/configuration")

require "http/client"

url = "{{baseUrl}}/audit/configuration"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/audit/configuration"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/audit/configuration");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/configuration"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/audit/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/audit/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/configuration"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/configuration")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/audit/configuration")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/audit/configuration');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/audit/configuration'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/configuration';
const options = {method: 'DELETE'};

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}}/audit/configuration',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/audit/configuration")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/audit/configuration',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/audit/configuration'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/audit/configuration');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/audit/configuration'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/configuration';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/configuration"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/audit/configuration" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/configuration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/audit/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/audit/configuration');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/audit/configuration');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/configuration' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/configuration' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/audit/configuration")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/configuration"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/configuration"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/configuration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/audit/configuration') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/configuration";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/audit/configuration

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/audit/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/configuration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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}}/audit/suppressions/delete");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/audit/suppressions/delete" {:content-type :json
                                                                      :form-params {:checkName ""
                                                                                    :resourceIdentifier {:deviceCertificateId ""
                                                                                                         :caCertificateId ""
                                                                                                         :cognitoIdentityPoolId ""
                                                                                                         :clientId ""
                                                                                                         :policyVersionIdentifier ""
                                                                                                         :account ""
                                                                                                         :iamRoleArn ""
                                                                                                         :roleAliasArn ""
                                                                                                         :issuerCertificateIdentifier ""
                                                                                                         :deviceCertificateArn ""}}})

require "http/client"

url = "{{baseUrl}}/audit/suppressions/delete"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\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}}/audit/suppressions/delete"),
    Content = new StringContent("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\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}}/audit/suppressions/delete");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/audit/suppressions/delete"

	payload := strings.NewReader("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	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/audit/suppressions/delete HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 333

{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/audit/suppressions/delete")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/audit/suppressions/delete"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\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  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/audit/suppressions/delete")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/audit/suppressions/delete")
  .header("content-type", "application/json")
  .body("{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/audit/suppressions/delete');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/suppressions/delete',
  headers: {'content-type': 'application/json'},
  data: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/audit/suppressions/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checkName":"","resourceIdentifier":{"deviceCertificateId":"","caCertificateId":"","cognitoIdentityPoolId":"","clientId":"","policyVersionIdentifier":"","account":"","iamRoleArn":"","roleAliasArn":"","issuerCertificateIdentifier":"","deviceCertificateArn":""}}'
};

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}}/audit/suppressions/delete',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checkName": "",\n  "resourceIdentifier": {\n    "deviceCertificateId": "",\n    "caCertificateId": "",\n    "cognitoIdentityPoolId": "",\n    "clientId": "",\n    "policyVersionIdentifier": "",\n    "account": "",\n    "iamRoleArn": "",\n    "roleAliasArn": "",\n    "issuerCertificateIdentifier": "",\n    "deviceCertificateArn": ""\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  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/audit/suppressions/delete")
  .post(body)
  .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/audit/suppressions/delete',
  headers: {
    '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({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/audit/suppressions/delete',
  headers: {'content-type': 'application/json'},
  body: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    }
  },
  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}}/audit/suppressions/delete');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  checkName: '',
  resourceIdentifier: {
    deviceCertificateId: '',
    caCertificateId: '',
    cognitoIdentityPoolId: '',
    clientId: '',
    policyVersionIdentifier: '',
    account: '',
    iamRoleArn: '',
    roleAliasArn: '',
    issuerCertificateIdentifier: '',
    deviceCertificateArn: ''
  }
});

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}}/audit/suppressions/delete',
  headers: {'content-type': 'application/json'},
  data: {
    checkName: '',
    resourceIdentifier: {
      deviceCertificateId: '',
      caCertificateId: '',
      cognitoIdentityPoolId: '',
      clientId: '',
      policyVersionIdentifier: '',
      account: '',
      iamRoleArn: '',
      roleAliasArn: '',
      issuerCertificateIdentifier: '',
      deviceCertificateArn: ''
    }
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/audit/suppressions/delete';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checkName":"","resourceIdentifier":{"deviceCertificateId":"","caCertificateId":"","cognitoIdentityPoolId":"","clientId":"","policyVersionIdentifier":"","account":"","iamRoleArn":"","roleAliasArn":"","issuerCertificateIdentifier":"","deviceCertificateArn":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"checkName": @"",
                              @"resourceIdentifier": @{ @"deviceCertificateId": @"", @"caCertificateId": @"", @"cognitoIdentityPoolId": @"", @"clientId": @"", @"policyVersionIdentifier": @"", @"account": @"", @"iamRoleArn": @"", @"roleAliasArn": @"", @"issuerCertificateIdentifier": @"", @"deviceCertificateArn": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/audit/suppressions/delete"]
                                                       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}}/audit/suppressions/delete" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/audit/suppressions/delete",
  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([
    'checkName' => '',
    'resourceIdentifier' => [
        'deviceCertificateId' => '',
        'caCertificateId' => '',
        'cognitoIdentityPoolId' => '',
        'clientId' => '',
        'policyVersionIdentifier' => '',
        'account' => '',
        'iamRoleArn' => '',
        'roleAliasArn' => '',
        'issuerCertificateIdentifier' => '',
        'deviceCertificateArn' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/audit/suppressions/delete', [
  'body' => '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/audit/suppressions/delete');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'checkName' => '',
  'resourceIdentifier' => [
    'deviceCertificateId' => '',
    'caCertificateId' => '',
    'cognitoIdentityPoolId' => '',
    'clientId' => '',
    'policyVersionIdentifier' => '',
    'account' => '',
    'iamRoleArn' => '',
    'roleAliasArn' => '',
    'issuerCertificateIdentifier' => '',
    'deviceCertificateArn' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'checkName' => '',
  'resourceIdentifier' => [
    'deviceCertificateId' => '',
    'caCertificateId' => '',
    'cognitoIdentityPoolId' => '',
    'clientId' => '',
    'policyVersionIdentifier' => '',
    'account' => '',
    'iamRoleArn' => '',
    'roleAliasArn' => '',
    'issuerCertificateIdentifier' => '',
    'deviceCertificateArn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/audit/suppressions/delete');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/audit/suppressions/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/audit/suppressions/delete' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/audit/suppressions/delete", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/audit/suppressions/delete"

payload = {
    "checkName": "",
    "resourceIdentifier": {
        "deviceCertificateId": "",
        "caCertificateId": "",
        "cognitoIdentityPoolId": "",
        "clientId": "",
        "policyVersionIdentifier": "",
        "account": "",
        "iamRoleArn": "",
        "roleAliasArn": "",
        "issuerCertificateIdentifier": "",
        "deviceCertificateArn": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/audit/suppressions/delete"

payload <- "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/audit/suppressions/delete")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\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/audit/suppressions/delete') do |req|
  req.body = "{\n  \"checkName\": \"\",\n  \"resourceIdentifier\": {\n    \"deviceCertificateId\": \"\",\n    \"caCertificateId\": \"\",\n    \"cognitoIdentityPoolId\": \"\",\n    \"clientId\": \"\",\n    \"policyVersionIdentifier\": \"\",\n    \"account\": \"\",\n    \"iamRoleArn\": \"\",\n    \"roleAliasArn\": \"\",\n    \"issuerCertificateIdentifier\": \"\",\n    \"deviceCertificateArn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/audit/suppressions/delete";

    let payload = json!({
        "checkName": "",
        "resourceIdentifier": json!({
            "deviceCertificateId": "",
            "caCertificateId": "",
            "cognitoIdentityPoolId": "",
            "clientId": "",
            "policyVersionIdentifier": "",
            "account": "",
            "iamRoleArn": "",
            "roleAliasArn": "",
            "issuerCertificateIdentifier": "",
            "deviceCertificateArn": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    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 '{
  "checkName": "",
  "resourceIdentifier": {
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  }
}' |  \
  http POST {{baseUrl}}/audit/suppressions/delete \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "checkName": "",\n  "resourceIdentifier": {\n    "deviceCertificateId": "",\n    "caCertificateId": "",\n    "cognitoIdentityPoolId": "",\n    "clientId": "",\n    "policyVersionIdentifier": "",\n    "account": "",\n    "iamRoleArn": "",\n    "roleAliasArn": "",\n    "issuerCertificateIdentifier": "",\n    "deviceCertificateArn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/audit/suppressions/delete

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "checkName": "",
  "resourceIdentifier": [
    "deviceCertificateId": "",
    "caCertificateId": "",
    "cognitoIdentityPoolId": "",
    "clientId": "",
    "policyVersionIdentifier": "",
    "account": "",
    "iamRoleArn": "",
    "roleAliasArn": "",
    "issuerCertificateIdentifier": "",
    "deviceCertificateArn": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/audit/suppressions/delete")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/authorizer/:authorizerName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/authorizer/:authorizerName")

require "http/client"

url = "{{baseUrl}}/authorizer/:authorizerName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/authorizer/:authorizerName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/authorizer/:authorizerName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/authorizer/:authorizerName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/authorizer/:authorizerName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/authorizer/:authorizerName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/authorizer/:authorizerName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/authorizer/:authorizerName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/authorizer/:authorizerName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/authorizer/:authorizerName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authorizer/:authorizerName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/authorizer/:authorizerName';
const options = {method: 'DELETE'};

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}}/authorizer/:authorizerName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/authorizer/:authorizerName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/authorizer/:authorizerName',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authorizer/:authorizerName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/authorizer/:authorizerName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/authorizer/:authorizerName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/authorizer/:authorizerName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/authorizer/:authorizerName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/authorizer/:authorizerName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/authorizer/:authorizerName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/authorizer/:authorizerName');

echo $response->getBody();

setUrl('{{baseUrl}}/authorizer/:authorizerName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/authorizer/:authorizerName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/authorizer/:authorizerName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/authorizer/:authorizerName' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/authorizer/:authorizerName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/authorizer/:authorizerName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/authorizer/:authorizerName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/authorizer/:authorizerName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/authorizer/:authorizerName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/authorizer/:authorizerName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/authorizer/:authorizerName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/authorizer/:authorizerName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/authorizer/:authorizerName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/billing-groups/:billingGroupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/billing-groups/:billingGroupName")

require "http/client"

url = "{{baseUrl}}/billing-groups/:billingGroupName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/billing-groups/:billingGroupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/billing-groups/:billingGroupName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/billing-groups/:billingGroupName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/billing-groups/:billingGroupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/billing-groups/:billingGroupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/billing-groups/:billingGroupName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/billing-groups/:billingGroupName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/billing-groups/:billingGroupName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/billing-groups/:billingGroupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/billing-groups/:billingGroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/billing-groups/:billingGroupName';
const options = {method: 'DELETE'};

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}}/billing-groups/:billingGroupName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/billing-groups/:billingGroupName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/billing-groups/:billingGroupName',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/billing-groups/:billingGroupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/billing-groups/:billingGroupName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/billing-groups/:billingGroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/billing-groups/:billingGroupName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/billing-groups/:billingGroupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/billing-groups/:billingGroupName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/billing-groups/:billingGroupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/billing-groups/:billingGroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/billing-groups/:billingGroupName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/billing-groups/:billingGroupName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/billing-groups/:billingGroupName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/billing-groups/:billingGroupName' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/billing-groups/:billingGroupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/billing-groups/:billingGroupName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/billing-groups/:billingGroupName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/billing-groups/:billingGroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/billing-groups/:billingGroupName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/billing-groups/:billingGroupName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/billing-groups/:billingGroupName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/billing-groups/:billingGroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/billing-groups/:billingGroupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cacertificate/:caCertificateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/cacertificate/:caCertificateId")

require "http/client"

url = "{{baseUrl}}/cacertificate/:caCertificateId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/cacertificate/:caCertificateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cacertificate/:caCertificateId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/cacertificate/:caCertificateId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/cacertificate/:caCertificateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/cacertificate/:caCertificateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cacertificate/:caCertificateId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/cacertificate/:caCertificateId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/cacertificate/:caCertificateId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/cacertificate/:caCertificateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cacertificate/:caCertificateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/cacertificate/:caCertificateId';
const options = {method: 'DELETE'};

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}}/cacertificate/:caCertificateId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cacertificate/:caCertificateId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cacertificate/:caCertificateId',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cacertificate/:caCertificateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/cacertificate/:caCertificateId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cacertificate/:caCertificateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/cacertificate/:caCertificateId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cacertificate/:caCertificateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/cacertificate/:caCertificateId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/cacertificate/:caCertificateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/cacertificate/:caCertificateId');

echo $response->getBody();

setUrl('{{baseUrl}}/cacertificate/:caCertificateId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/cacertificate/:caCertificateId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/cacertificate/:caCertificateId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/cacertificate/:caCertificateId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/cacertificate/:caCertificateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/cacertificate/:caCertificateId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/cacertificate/:caCertificateId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cacertificate/:caCertificateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/cacertificate/:caCertificateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/cacertificate/:caCertificateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/cacertificate/:caCertificateId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/cacertificate/:caCertificateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cacertificate/:caCertificateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/certificates/:certificateId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/certificates/:certificateId")

require "http/client"

url = "{{baseUrl}}/certificates/:certificateId"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/certificates/:certificateId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/certificates/:certificateId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/certificates/:certificateId"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/certificates/:certificateId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/certificates/:certificateId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/certificates/:certificateId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/certificates/:certificateId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/certificates/:certificateId")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/certificates/:certificateId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/certificates/:certificateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/certificates/:certificateId';
const options = {method: 'DELETE'};

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}}/certificates/:certificateId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/certificates/:certificateId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/certificates/:certificateId',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/certificates/:certificateId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/certificates/:certificateId');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/certificates/:certificateId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/certificates/:certificateId';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/certificates/:certificateId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/certificates/:certificateId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/certificates/:certificateId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/certificates/:certificateId');

echo $response->getBody();

setUrl('{{baseUrl}}/certificates/:certificateId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/certificates/:certificateId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/certificates/:certificateId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/certificates/:certificateId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/certificates/:certificateId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/certificates/:certificateId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/certificates/:certificateId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/certificates/:certificateId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/certificates/:certificateId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/certificates/:certificateId";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/certificates/:certificateId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/certificates/:certificateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/certificates/:certificateId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/custom-metric/:metricName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/custom-metric/:metricName")

require "http/client"

url = "{{baseUrl}}/custom-metric/:metricName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/custom-metric/:metricName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/custom-metric/:metricName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/custom-metric/:metricName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/custom-metric/:metricName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/custom-metric/:metricName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/custom-metric/:metricName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/custom-metric/:metricName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/custom-metric/:metricName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/custom-metric/:metricName');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/custom-metric/:metricName'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/custom-metric/:metricName';
const options = {method: 'DELETE'};

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}}/custom-metric/:metricName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/custom-metric/:metricName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/custom-metric/:metricName',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/custom-metric/:metricName'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/custom-metric/:metricName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/custom-metric/:metricName'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/custom-metric/:metricName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/custom-metric/:metricName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/custom-metric/:metricName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/custom-metric/:metricName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/custom-metric/:metricName');

echo $response->getBody();

setUrl('{{baseUrl}}/custom-metric/:metricName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/custom-metric/:metricName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/custom-metric/:metricName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/custom-metric/:metricName' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/custom-metric/:metricName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/custom-metric/:metricName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/custom-metric/:metricName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/custom-metric/:metricName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/custom-metric/:metricName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/custom-metric/:metricName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/custom-metric/:metricName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/custom-metric/:metricName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/custom-metric/:metricName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dimensions/:name");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dimensions/:name")

require "http/client"

url = "{{baseUrl}}/dimensions/:name"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/dimensions/:name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dimensions/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dimensions/:name"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/dimensions/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dimensions/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dimensions/:name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/dimensions/:name")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/dimensions/:name")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/dimensions/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dimensions/:name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/dimensions/:name';
const options = {method: 'DELETE'};

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}}/dimensions/:name',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dimensions/:name")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dimensions/:name',
  headers: {}
};

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.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/dimensions/:name'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dimensions/: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: 'DELETE', url: '{{baseUrl}}/dimensions/:name'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/dimensions/:name';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dimensions/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/dimensions/:name" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/dimensions/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/dimensions/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/dimensions/:name');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/dimensions/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dimensions/:name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dimensions/:name' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dimensions/:name")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/dimensions/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dimensions/:name"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dimensions/:name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/dimensions/:name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dimensions/:name";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/dimensions/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dimensions/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dimensions/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domainConfigurations/:domainConfigurationName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/domainConfigurations/:domainConfigurationName")

require "http/client"

url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/domainConfigurations/:domainConfigurationName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/domainConfigurations/:domainConfigurationName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/domainConfigurations/:domainConfigurationName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/domainConfigurations/:domainConfigurationName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/domainConfigurations/:domainConfigurationName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainConfigurations/:domainConfigurationName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/domainConfigurations/:domainConfigurationName';
const options = {method: 'DELETE'};

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}}/domainConfigurations/:domainConfigurationName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/domainConfigurations/:domainConfigurationName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/domainConfigurations/:domainConfigurationName',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainConfigurations/:domainConfigurationName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/domainConfigurations/:domainConfigurationName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/domainConfigurations/:domainConfigurationName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/domainConfigurations/:domainConfigurationName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domainConfigurations/:domainConfigurationName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/domainConfigurations/:domainConfigurationName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/domainConfigurations/:domainConfigurationName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/domainConfigurations/:domainConfigurationName');

echo $response->getBody();

setUrl('{{baseUrl}}/domainConfigurations/:domainConfigurationName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/domainConfigurations/:domainConfigurationName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/domainConfigurations/:domainConfigurationName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/domainConfigurations/:domainConfigurationName' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/domainConfigurations/:domainConfigurationName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/domainConfigurations/:domainConfigurationName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/domainConfigurations/:domainConfigurationName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/domainConfigurations/:domainConfigurationName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/domainConfigurations/:domainConfigurationName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/domainConfigurations/:domainConfigurationName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/domainConfigurations/:domainConfigurationName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domainConfigurations/:domainConfigurationName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/dynamic-thing-groups/:thingGroupName");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/dynamic-thing-groups/:thingGroupName")

require "http/client"

url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/dynamic-thing-groups/:thingGroupName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dynamic-thing-groups/:thingGroupName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/dynamic-thing-groups/:thingGroupName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dynamic-thing-groups/:thingGroupName"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/dynamic-thing-groups/:thingGroupName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dynamic-thing-groups/:thingGroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/dynamic-thing-groups/:thingGroupName';
const options = {method: 'DELETE'};

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}}/dynamic-thing-groups/:thingGroupName',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dynamic-thing-groups/:thingGroupName',
  headers: {}
};

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.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dynamic-thing-groups/:thingGroupName'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dynamic-thing-groups/:thingGroupName');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/dynamic-thing-groups/:thingGroupName'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/dynamic-thing-groups/:thingGroupName';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dynamic-thing-groups/:thingGroupName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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}}/dynamic-thing-groups/:thingGroupName" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/dynamic-thing-groups/:thingGroupName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/dynamic-thing-groups/:thingGroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/dynamic-thing-groups/:thingGroupName');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/dynamic-thing-groups/:thingGroupName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dynamic-thing-groups/:thingGroupName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dynamic-thing-groups/:thingGroupName' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/dynamic-thing-groups/:thingGroupName")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dynamic-thing-groups/:thingGroupName"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dynamic-thing-groups/:thingGroupName")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/dynamic-thing-groups/:thingGroupName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dynamic-thing-groups/:thingGroupName";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/dynamic-thing-groups/:thingGroupName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dynamic-thing-groups/:thingGroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dynamic-thing-groups/:thingGroupName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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()