CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/orders/:OrderId/cancel");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/orders/:OrderId/cancel")

require "http/client"

url = "{{baseUrl}}/orders/:OrderId/cancel"

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}}/orders/:OrderId/cancel"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/orders/:OrderId/cancel");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/orders/:OrderId/cancel"

	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/orders/:OrderId/cancel HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/orders/:OrderId/cancel")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/orders/:OrderId/cancel"))
    .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}}/orders/:OrderId/cancel")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/orders/:OrderId/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('POST', '{{baseUrl}}/orders/:OrderId/cancel');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/orders/:OrderId/cancel'};

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

const url = '{{baseUrl}}/orders/:OrderId/cancel';
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}}/orders/:OrderId/cancel',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/orders/:OrderId/cancel")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/orders/:OrderId/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: 'POST', url: '{{baseUrl}}/orders/:OrderId/cancel'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/orders/:OrderId/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: 'POST', url: '{{baseUrl}}/orders/:OrderId/cancel'};

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

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

const url = '{{baseUrl}}/orders/:OrderId/cancel';
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}}/orders/:OrderId/cancel"]
                                                       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}}/orders/:OrderId/cancel" in

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

 "{{baseUrl}}/orders/:OrderId/cancel",
  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}}/orders/:OrderId/cancel');

echo $response->getBody();

setUrl('{{baseUrl}}/orders/:OrderId/cancel');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/orders/:OrderId/cancel');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/orders/:OrderId/cancel' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/orders/:OrderId/cancel' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/orders/:OrderId/cancel")

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

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

import requests

url = "{{baseUrl}}/orders/:OrderId/cancel"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/orders/:OrderId/cancel"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/orders/:OrderId/cancel")

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/orders/:OrderId/cancel') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/orders/:OrderId/cancel";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/orders/:OrderId/cancel

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/orders/:OrderId/cancel

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/orders/:OrderId/cancel")! 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}}/orders");

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  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/orders" {:content-type :json
                                                   :form-params {:OutpostIdentifier ""
                                                                 :LineItems [{:CatalogItemId ""
                                                                              :Quantity ""}]
                                                                 :PaymentOption ""
                                                                 :PaymentTerm ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/orders"

	payload := strings.NewReader("{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\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/orders HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 155

{
  "OutpostIdentifier": "",
  "LineItems": [
    {
      "CatalogItemId": "",
      "Quantity": ""
    }
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/orders")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/orders")
  .header("content-type", "application/json")
  .body("{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  OutpostIdentifier: '',
  LineItems: [
    {
      CatalogItemId: '',
      Quantity: ''
    }
  ],
  PaymentOption: '',
  PaymentTerm: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/orders');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/orders',
  headers: {'content-type': 'application/json'},
  data: {
    OutpostIdentifier: '',
    LineItems: [{CatalogItemId: '', Quantity: ''}],
    PaymentOption: '',
    PaymentTerm: ''
  }
};

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

const url = '{{baseUrl}}/orders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"OutpostIdentifier":"","LineItems":[{"CatalogItemId":"","Quantity":""}],"PaymentOption":"","PaymentTerm":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/orders',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "OutpostIdentifier": "",\n  "LineItems": [\n    {\n      "CatalogItemId": "",\n      "Quantity": ""\n    }\n  ],\n  "PaymentOption": "",\n  "PaymentTerm": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/orders")
  .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/orders',
  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({
  OutpostIdentifier: '',
  LineItems: [{CatalogItemId: '', Quantity: ''}],
  PaymentOption: '',
  PaymentTerm: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/orders',
  headers: {'content-type': 'application/json'},
  body: {
    OutpostIdentifier: '',
    LineItems: [{CatalogItemId: '', Quantity: ''}],
    PaymentOption: '',
    PaymentTerm: ''
  },
  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}}/orders');

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

req.type('json');
req.send({
  OutpostIdentifier: '',
  LineItems: [
    {
      CatalogItemId: '',
      Quantity: ''
    }
  ],
  PaymentOption: '',
  PaymentTerm: ''
});

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}}/orders',
  headers: {'content-type': 'application/json'},
  data: {
    OutpostIdentifier: '',
    LineItems: [{CatalogItemId: '', Quantity: ''}],
    PaymentOption: '',
    PaymentTerm: ''
  }
};

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

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

const url = '{{baseUrl}}/orders';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"OutpostIdentifier":"","LineItems":[{"CatalogItemId":"","Quantity":""}],"PaymentOption":"","PaymentTerm":""}'
};

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 = @{ @"OutpostIdentifier": @"",
                              @"LineItems": @[ @{ @"CatalogItemId": @"", @"Quantity": @"" } ],
                              @"PaymentOption": @"",
                              @"PaymentTerm": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/orders"]
                                                       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}}/orders" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}" in

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

 "{{baseUrl}}/orders",
  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([
    'OutpostIdentifier' => '',
    'LineItems' => [
        [
                'CatalogItemId' => '',
                'Quantity' => ''
        ]
    ],
    'PaymentOption' => '',
    'PaymentTerm' => ''
  ]),
  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}}/orders', [
  'body' => '{
  "OutpostIdentifier": "",
  "LineItems": [
    {
      "CatalogItemId": "",
      "Quantity": ""
    }
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/orders');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'OutpostIdentifier' => '',
  'LineItems' => [
    [
        'CatalogItemId' => '',
        'Quantity' => ''
    ]
  ],
  'PaymentOption' => '',
  'PaymentTerm' => ''
]));

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

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

append(json_encode([
  'OutpostIdentifier' => '',
  'LineItems' => [
    [
        'CatalogItemId' => '',
        'Quantity' => ''
    ]
  ],
  'PaymentOption' => '',
  'PaymentTerm' => ''
]));
$request->setRequestUrl('{{baseUrl}}/orders');
$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}}/orders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OutpostIdentifier": "",
  "LineItems": [
    {
      "CatalogItemId": "",
      "Quantity": ""
    }
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/orders' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "OutpostIdentifier": "",
  "LineItems": [
    {
      "CatalogItemId": "",
      "Quantity": ""
    }
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
}'

import http.client

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

payload = "{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/orders"

payload = {
    "OutpostIdentifier": "",
    "LineItems": [
        {
            "CatalogItemId": "",
            "Quantity": ""
        }
    ],
    "PaymentOption": "",
    "PaymentTerm": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/orders"

payload <- "{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\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}}/orders")

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  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\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/orders') do |req|
  req.body = "{\n  \"OutpostIdentifier\": \"\",\n  \"LineItems\": [\n    {\n      \"CatalogItemId\": \"\",\n      \"Quantity\": \"\"\n    }\n  ],\n  \"PaymentOption\": \"\",\n  \"PaymentTerm\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "OutpostIdentifier": "",
        "LineItems": (
            json!({
                "CatalogItemId": "",
                "Quantity": ""
            })
        ),
        "PaymentOption": "",
        "PaymentTerm": ""
    });

    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 '{
  "OutpostIdentifier": "",
  "LineItems": [
    {
      "CatalogItemId": "",
      "Quantity": ""
    }
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
}' |  \
  http POST {{baseUrl}}/orders \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "OutpostIdentifier": "",\n  "LineItems": [\n    {\n      "CatalogItemId": "",\n      "Quantity": ""\n    }\n  ],\n  "PaymentOption": "",\n  "PaymentTerm": ""\n}' \
  --output-document \
  - {{baseUrl}}/orders

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "OutpostIdentifier": "",
  "LineItems": [
    [
      "CatalogItemId": "",
      "Quantity": ""
    ]
  ],
  "PaymentOption": "",
  "PaymentTerm": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/orders")! 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}}/outposts");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/outposts" {:content-type :json
                                                     :form-params {:Name ""
                                                                   :Description ""
                                                                   :SiteId ""
                                                                   :AvailabilityZone ""
                                                                   :AvailabilityZoneId ""
                                                                   :Tags {}
                                                                   :SupportedHardwareType ""}})

require "http/client"

url = "{{baseUrl}}/outposts"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\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}}/outposts"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\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}}/outposts");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\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/outposts HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 152

{
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": {},
  "SupportedHardwareType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/outposts")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/outposts")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/outposts")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  SiteId: '',
  AvailabilityZone: '',
  AvailabilityZoneId: '',
  Tags: {},
  SupportedHardwareType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/outposts');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/outposts',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    SiteId: '',
    AvailabilityZone: '',
    AvailabilityZoneId: '',
    Tags: {},
    SupportedHardwareType: ''
  }
};

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

const url = '{{baseUrl}}/outposts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","SiteId":"","AvailabilityZone":"","AvailabilityZoneId":"","Tags":{},"SupportedHardwareType":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/outposts',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "SiteId": "",\n  "AvailabilityZone": "",\n  "AvailabilityZoneId": "",\n  "Tags": {},\n  "SupportedHardwareType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/outposts")
  .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/outposts',
  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({
  Name: '',
  Description: '',
  SiteId: '',
  AvailabilityZone: '',
  AvailabilityZoneId: '',
  Tags: {},
  SupportedHardwareType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/outposts',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    SiteId: '',
    AvailabilityZone: '',
    AvailabilityZoneId: '',
    Tags: {},
    SupportedHardwareType: ''
  },
  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}}/outposts');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  SiteId: '',
  AvailabilityZone: '',
  AvailabilityZoneId: '',
  Tags: {},
  SupportedHardwareType: ''
});

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}}/outposts',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    SiteId: '',
    AvailabilityZone: '',
    AvailabilityZoneId: '',
    Tags: {},
    SupportedHardwareType: ''
  }
};

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

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

const url = '{{baseUrl}}/outposts';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","SiteId":"","AvailabilityZone":"","AvailabilityZoneId":"","Tags":{},"SupportedHardwareType":""}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"SiteId": @"",
                              @"AvailabilityZone": @"",
                              @"AvailabilityZoneId": @"",
                              @"Tags": @{  },
                              @"SupportedHardwareType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/outposts"]
                                                       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}}/outposts" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}" in

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

 "{{baseUrl}}/outposts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'SiteId' => '',
    'AvailabilityZone' => '',
    'AvailabilityZoneId' => '',
    'Tags' => [
        
    ],
    'SupportedHardwareType' => ''
  ]),
  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}}/outposts', [
  'body' => '{
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": {},
  "SupportedHardwareType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/outposts');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'SiteId' => '',
  'AvailabilityZone' => '',
  'AvailabilityZoneId' => '',
  'Tags' => [
    
  ],
  'SupportedHardwareType' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'SiteId' => '',
  'AvailabilityZone' => '',
  'AvailabilityZoneId' => '',
  'Tags' => [
    
  ],
  'SupportedHardwareType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/outposts');
$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}}/outposts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": {},
  "SupportedHardwareType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": {},
  "SupportedHardwareType": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/outposts"

payload = {
    "Name": "",
    "Description": "",
    "SiteId": "",
    "AvailabilityZone": "",
    "AvailabilityZoneId": "",
    "Tags": {},
    "SupportedHardwareType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\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}}/outposts")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\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/outposts') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SiteId\": \"\",\n  \"AvailabilityZone\": \"\",\n  \"AvailabilityZoneId\": \"\",\n  \"Tags\": {},\n  \"SupportedHardwareType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "SiteId": "",
        "AvailabilityZone": "",
        "AvailabilityZoneId": "",
        "Tags": json!({}),
        "SupportedHardwareType": ""
    });

    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 '{
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": {},
  "SupportedHardwareType": ""
}' |  \
  http POST {{baseUrl}}/outposts \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "SiteId": "",\n  "AvailabilityZone": "",\n  "AvailabilityZoneId": "",\n  "Tags": {},\n  "SupportedHardwareType": ""\n}' \
  --output-document \
  - {{baseUrl}}/outposts

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "SiteId": "",
  "AvailabilityZone": "",
  "AvailabilityZoneId": "",
  "Tags": [],
  "SupportedHardwareType": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts")! 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}}/sites");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/sites" {:content-type :json
                                                  :form-params {:Name ""
                                                                :Description ""
                                                                :Notes ""
                                                                :Tags {}
                                                                :OperatingAddress {:ContactName ""
                                                                                   :ContactPhoneNumber ""
                                                                                   :AddressLine1 ""
                                                                                   :AddressLine2 ""
                                                                                   :AddressLine3 ""
                                                                                   :City ""
                                                                                   :StateOrRegion ""
                                                                                   :DistrictOrCounty ""
                                                                                   :PostalCode ""
                                                                                   :CountryCode ""
                                                                                   :Municipality ""}
                                                                :ShippingAddress {:ContactName ""
                                                                                  :ContactPhoneNumber ""
                                                                                  :AddressLine1 ""
                                                                                  :AddressLine2 ""
                                                                                  :AddressLine3 ""
                                                                                  :City ""
                                                                                  :StateOrRegion ""
                                                                                  :DistrictOrCounty ""
                                                                                  :PostalCode ""
                                                                                  :CountryCode ""
                                                                                  :Municipality ""}
                                                                :RackPhysicalProperties {:PowerDrawKva ""
                                                                                         :PowerPhase ""
                                                                                         :PowerConnector ""
                                                                                         :PowerFeedDrop ""
                                                                                         :UplinkGbps ""
                                                                                         :UplinkCount ""
                                                                                         :FiberOpticCableType ""
                                                                                         :OpticalStandard ""
                                                                                         :MaximumSupportedWeightLbs ""}}})

require "http/client"

url = "{{baseUrl}}/sites"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\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}}/sites"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\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}}/sites");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\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/sites HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 918

{
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": {},
  "OperatingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "ShippingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "RackPhysicalProperties": {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/sites")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sites")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/sites")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  Notes: '',
  Tags: {},
  OperatingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  ShippingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  RackPhysicalProperties: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/sites');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sites',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    Notes: '',
    Tags: {},
    OperatingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    ShippingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    RackPhysicalProperties: {
      PowerDrawKva: '',
      PowerPhase: '',
      PowerConnector: '',
      PowerFeedDrop: '',
      UplinkGbps: '',
      UplinkCount: '',
      FiberOpticCableType: '',
      OpticalStandard: '',
      MaximumSupportedWeightLbs: ''
    }
  }
};

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

const url = '{{baseUrl}}/sites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Notes":"","Tags":{},"OperatingAddress":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""},"ShippingAddress":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""},"RackPhysicalProperties":{"PowerDrawKva":"","PowerPhase":"","PowerConnector":"","PowerFeedDrop":"","UplinkGbps":"","UplinkCount":"","FiberOpticCableType":"","OpticalStandard":"","MaximumSupportedWeightLbs":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/sites',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "Notes": "",\n  "Tags": {},\n  "OperatingAddress": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\n  },\n  "ShippingAddress": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\n  },\n  "RackPhysicalProperties": {\n    "PowerDrawKva": "",\n    "PowerPhase": "",\n    "PowerConnector": "",\n    "PowerFeedDrop": "",\n    "UplinkGbps": "",\n    "UplinkCount": "",\n    "FiberOpticCableType": "",\n    "OpticalStandard": "",\n    "MaximumSupportedWeightLbs": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sites")
  .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/sites',
  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({
  Name: '',
  Description: '',
  Notes: '',
  Tags: {},
  OperatingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  ShippingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  RackPhysicalProperties: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/sites',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    Description: '',
    Notes: '',
    Tags: {},
    OperatingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    ShippingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    RackPhysicalProperties: {
      PowerDrawKva: '',
      PowerPhase: '',
      PowerConnector: '',
      PowerFeedDrop: '',
      UplinkGbps: '',
      UplinkCount: '',
      FiberOpticCableType: '',
      OpticalStandard: '',
      MaximumSupportedWeightLbs: ''
    }
  },
  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}}/sites');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  Notes: '',
  Tags: {},
  OperatingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  ShippingAddress: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  },
  RackPhysicalProperties: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  }
});

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}}/sites',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    Description: '',
    Notes: '',
    Tags: {},
    OperatingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    ShippingAddress: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    },
    RackPhysicalProperties: {
      PowerDrawKva: '',
      PowerPhase: '',
      PowerConnector: '',
      PowerFeedDrop: '',
      UplinkGbps: '',
      UplinkCount: '',
      FiberOpticCableType: '',
      OpticalStandard: '',
      MaximumSupportedWeightLbs: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/sites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Notes":"","Tags":{},"OperatingAddress":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""},"ShippingAddress":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""},"RackPhysicalProperties":{"PowerDrawKva":"","PowerPhase":"","PowerConnector":"","PowerFeedDrop":"","UplinkGbps":"","UplinkCount":"","FiberOpticCableType":"","OpticalStandard":"","MaximumSupportedWeightLbs":""}}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"Notes": @"",
                              @"Tags": @{  },
                              @"OperatingAddress": @{ @"ContactName": @"", @"ContactPhoneNumber": @"", @"AddressLine1": @"", @"AddressLine2": @"", @"AddressLine3": @"", @"City": @"", @"StateOrRegion": @"", @"DistrictOrCounty": @"", @"PostalCode": @"", @"CountryCode": @"", @"Municipality": @"" },
                              @"ShippingAddress": @{ @"ContactName": @"", @"ContactPhoneNumber": @"", @"AddressLine1": @"", @"AddressLine2": @"", @"AddressLine3": @"", @"City": @"", @"StateOrRegion": @"", @"DistrictOrCounty": @"", @"PostalCode": @"", @"CountryCode": @"", @"Municipality": @"" },
                              @"RackPhysicalProperties": @{ @"PowerDrawKva": @"", @"PowerPhase": @"", @"PowerConnector": @"", @"PowerFeedDrop": @"", @"UplinkGbps": @"", @"UplinkCount": @"", @"FiberOpticCableType": @"", @"OpticalStandard": @"", @"MaximumSupportedWeightLbs": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sites"]
                                                       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}}/sites" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/sites",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'Notes' => '',
    'Tags' => [
        
    ],
    'OperatingAddress' => [
        'ContactName' => '',
        'ContactPhoneNumber' => '',
        'AddressLine1' => '',
        'AddressLine2' => '',
        'AddressLine3' => '',
        'City' => '',
        'StateOrRegion' => '',
        'DistrictOrCounty' => '',
        'PostalCode' => '',
        'CountryCode' => '',
        'Municipality' => ''
    ],
    'ShippingAddress' => [
        'ContactName' => '',
        'ContactPhoneNumber' => '',
        'AddressLine1' => '',
        'AddressLine2' => '',
        'AddressLine3' => '',
        'City' => '',
        'StateOrRegion' => '',
        'DistrictOrCounty' => '',
        'PostalCode' => '',
        'CountryCode' => '',
        'Municipality' => ''
    ],
    'RackPhysicalProperties' => [
        'PowerDrawKva' => '',
        'PowerPhase' => '',
        'PowerConnector' => '',
        'PowerFeedDrop' => '',
        'UplinkGbps' => '',
        'UplinkCount' => '',
        'FiberOpticCableType' => '',
        'OpticalStandard' => '',
        'MaximumSupportedWeightLbs' => ''
    ]
  ]),
  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}}/sites', [
  'body' => '{
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": {},
  "OperatingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "ShippingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "RackPhysicalProperties": {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sites');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Description' => '',
  'Notes' => '',
  'Tags' => [
    
  ],
  'OperatingAddress' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ],
  'ShippingAddress' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ],
  'RackPhysicalProperties' => [
    'PowerDrawKva' => '',
    'PowerPhase' => '',
    'PowerConnector' => '',
    'PowerFeedDrop' => '',
    'UplinkGbps' => '',
    'UplinkCount' => '',
    'FiberOpticCableType' => '',
    'OpticalStandard' => '',
    'MaximumSupportedWeightLbs' => ''
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'Notes' => '',
  'Tags' => [
    
  ],
  'OperatingAddress' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ],
  'ShippingAddress' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ],
  'RackPhysicalProperties' => [
    'PowerDrawKva' => '',
    'PowerPhase' => '',
    'PowerConnector' => '',
    'PowerFeedDrop' => '',
    'UplinkGbps' => '',
    'UplinkCount' => '',
    'FiberOpticCableType' => '',
    'OpticalStandard' => '',
    'MaximumSupportedWeightLbs' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sites');
$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}}/sites' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": {},
  "OperatingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "ShippingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "RackPhysicalProperties": {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": {},
  "OperatingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "ShippingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "RackPhysicalProperties": {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/sites"

payload = {
    "Name": "",
    "Description": "",
    "Notes": "",
    "Tags": {},
    "OperatingAddress": {
        "ContactName": "",
        "ContactPhoneNumber": "",
        "AddressLine1": "",
        "AddressLine2": "",
        "AddressLine3": "",
        "City": "",
        "StateOrRegion": "",
        "DistrictOrCounty": "",
        "PostalCode": "",
        "CountryCode": "",
        "Municipality": ""
    },
    "ShippingAddress": {
        "ContactName": "",
        "ContactPhoneNumber": "",
        "AddressLine1": "",
        "AddressLine2": "",
        "AddressLine3": "",
        "City": "",
        "StateOrRegion": "",
        "DistrictOrCounty": "",
        "PostalCode": "",
        "CountryCode": "",
        "Municipality": ""
    },
    "RackPhysicalProperties": {
        "PowerDrawKva": "",
        "PowerPhase": "",
        "PowerConnector": "",
        "PowerFeedDrop": "",
        "UplinkGbps": "",
        "UplinkCount": "",
        "FiberOpticCableType": "",
        "OpticalStandard": "",
        "MaximumSupportedWeightLbs": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\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}}/sites")

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\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/sites') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\",\n  \"Tags\": {},\n  \"OperatingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"ShippingAddress\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  },\n  \"RackPhysicalProperties\": {\n    \"PowerDrawKva\": \"\",\n    \"PowerPhase\": \"\",\n    \"PowerConnector\": \"\",\n    \"PowerFeedDrop\": \"\",\n    \"UplinkGbps\": \"\",\n    \"UplinkCount\": \"\",\n    \"FiberOpticCableType\": \"\",\n    \"OpticalStandard\": \"\",\n    \"MaximumSupportedWeightLbs\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Name": "",
        "Description": "",
        "Notes": "",
        "Tags": json!({}),
        "OperatingAddress": json!({
            "ContactName": "",
            "ContactPhoneNumber": "",
            "AddressLine1": "",
            "AddressLine2": "",
            "AddressLine3": "",
            "City": "",
            "StateOrRegion": "",
            "DistrictOrCounty": "",
            "PostalCode": "",
            "CountryCode": "",
            "Municipality": ""
        }),
        "ShippingAddress": json!({
            "ContactName": "",
            "ContactPhoneNumber": "",
            "AddressLine1": "",
            "AddressLine2": "",
            "AddressLine3": "",
            "City": "",
            "StateOrRegion": "",
            "DistrictOrCounty": "",
            "PostalCode": "",
            "CountryCode": "",
            "Municipality": ""
        }),
        "RackPhysicalProperties": json!({
            "PowerDrawKva": "",
            "PowerPhase": "",
            "PowerConnector": "",
            "PowerFeedDrop": "",
            "UplinkGbps": "",
            "UplinkCount": "",
            "FiberOpticCableType": "",
            "OpticalStandard": "",
            "MaximumSupportedWeightLbs": ""
        })
    });

    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 '{
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": {},
  "OperatingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "ShippingAddress": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  },
  "RackPhysicalProperties": {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  }
}' |  \
  http POST {{baseUrl}}/sites \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "Notes": "",\n  "Tags": {},\n  "OperatingAddress": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\n  },\n  "ShippingAddress": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\n  },\n  "RackPhysicalProperties": {\n    "PowerDrawKva": "",\n    "PowerPhase": "",\n    "PowerConnector": "",\n    "PowerFeedDrop": "",\n    "UplinkGbps": "",\n    "UplinkCount": "",\n    "FiberOpticCableType": "",\n    "OpticalStandard": "",\n    "MaximumSupportedWeightLbs": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/sites

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "Notes": "",
  "Tags": [],
  "OperatingAddress": [
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  ],
  "ShippingAddress": [
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  ],
  "RackPhysicalProperties": [
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites")! 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}}/outposts/:OutpostId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/outposts/:OutpostId")

require "http/client"

url = "{{baseUrl}}/outposts/:OutpostId"

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}}/outposts/:OutpostId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/outposts/:OutpostId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts/:OutpostId"

	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/outposts/:OutpostId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/outposts/:OutpostId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts/:OutpostId"))
    .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}}/outposts/:OutpostId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/outposts/:OutpostId")
  .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}}/outposts/:OutpostId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/outposts/:OutpostId'};

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

const url = '{{baseUrl}}/outposts/:OutpostId';
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}}/outposts/:OutpostId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts/:OutpostId',
  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}}/outposts/:OutpostId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/outposts/:OutpostId');

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}}/outposts/:OutpostId'};

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

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

const url = '{{baseUrl}}/outposts/:OutpostId';
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}}/outposts/:OutpostId"]
                                                       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}}/outposts/:OutpostId" in

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

 "{{baseUrl}}/outposts/:OutpostId",
  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}}/outposts/:OutpostId');

echo $response->getBody();

setUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/outposts/:OutpostId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts/:OutpostId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/outposts/:OutpostId")

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

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

import requests

url = "{{baseUrl}}/outposts/:OutpostId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts/:OutpostId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts/:OutpostId")

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/outposts/:OutpostId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/outposts/:OutpostId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/outposts/:OutpostId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts/:OutpostId")! 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}}/sites/:SiteId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/sites/:SiteId")

require "http/client"

url = "{{baseUrl}}/sites/:SiteId"

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}}/sites/:SiteId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sites/:SiteId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId"

	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/sites/:SiteId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/sites/:SiteId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId"))
    .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}}/sites/:SiteId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/sites/:SiteId")
  .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}}/sites/:SiteId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/sites/:SiteId'};

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

const url = '{{baseUrl}}/sites/:SiteId';
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}}/sites/:SiteId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites/:SiteId',
  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}}/sites/:SiteId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/sites/:SiteId');

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}}/sites/:SiteId'};

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

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

const url = '{{baseUrl}}/sites/:SiteId';
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}}/sites/:SiteId"]
                                                       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}}/sites/:SiteId" in

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

 "{{baseUrl}}/sites/:SiteId",
  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}}/sites/:SiteId');

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/sites/:SiteId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sites/:SiteId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/sites/:SiteId")

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites/:SiteId")

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/sites/:SiteId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/sites/:SiteId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/sites/:SiteId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId")! 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}}/catalog/item/:CatalogItemId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/catalog/item/:CatalogItemId")

require "http/client"

url = "{{baseUrl}}/catalog/item/:CatalogItemId"

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}}/catalog/item/:CatalogItemId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/catalog/item/:CatalogItemId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/catalog/item/:CatalogItemId"

	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/catalog/item/:CatalogItemId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/catalog/item/:CatalogItemId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/catalog/item/:CatalogItemId"))
    .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}}/catalog/item/:CatalogItemId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/catalog/item/:CatalogItemId")
  .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}}/catalog/item/:CatalogItemId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/catalog/item/:CatalogItemId'};

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

const url = '{{baseUrl}}/catalog/item/:CatalogItemId';
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}}/catalog/item/:CatalogItemId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/catalog/item/:CatalogItemId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/catalog/item/:CatalogItemId',
  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}}/catalog/item/:CatalogItemId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/catalog/item/:CatalogItemId');

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}}/catalog/item/:CatalogItemId'};

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

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

const url = '{{baseUrl}}/catalog/item/:CatalogItemId';
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}}/catalog/item/:CatalogItemId"]
                                                       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}}/catalog/item/:CatalogItemId" in

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

 "{{baseUrl}}/catalog/item/:CatalogItemId",
  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}}/catalog/item/:CatalogItemId');

echo $response->getBody();

setUrl('{{baseUrl}}/catalog/item/:CatalogItemId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/catalog/item/:CatalogItemId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/catalog/item/:CatalogItemId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/catalog/item/:CatalogItemId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/catalog/item/:CatalogItemId")

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

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

import requests

url = "{{baseUrl}}/catalog/item/:CatalogItemId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/catalog/item/:CatalogItemId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/catalog/item/:CatalogItemId")

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/catalog/item/:CatalogItemId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/catalog/item/:CatalogItemId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/catalog/item/:CatalogItemId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/catalog/item/:CatalogItemId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/catalog/item/:CatalogItemId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connections/:ConnectionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/connections/:ConnectionId")

require "http/client"

url = "{{baseUrl}}/connections/:ConnectionId"

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}}/connections/:ConnectionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/connections/:ConnectionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/connections/:ConnectionId"

	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/connections/:ConnectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connections/:ConnectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connections/:ConnectionId"))
    .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}}/connections/:ConnectionId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/connections/:ConnectionId")
  .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}}/connections/:ConnectionId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/connections/:ConnectionId'};

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

const url = '{{baseUrl}}/connections/:ConnectionId';
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}}/connections/:ConnectionId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/connections/:ConnectionId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/connections/:ConnectionId',
  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}}/connections/:ConnectionId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/connections/:ConnectionId');

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}}/connections/:ConnectionId'};

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

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

const url = '{{baseUrl}}/connections/:ConnectionId';
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}}/connections/:ConnectionId"]
                                                       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}}/connections/:ConnectionId" in

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

 "{{baseUrl}}/connections/:ConnectionId",
  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}}/connections/:ConnectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/connections/:ConnectionId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/connections/:ConnectionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/connections/:ConnectionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/connections/:ConnectionId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/connections/:ConnectionId")

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

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

import requests

url = "{{baseUrl}}/connections/:ConnectionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/connections/:ConnectionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/connections/:ConnectionId")

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/connections/:ConnectionId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/connections/:ConnectionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/connections/:ConnectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections/:ConnectionId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/orders/:OrderId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/orders/:OrderId")

require "http/client"

url = "{{baseUrl}}/orders/:OrderId"

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}}/orders/:OrderId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/orders/:OrderId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/orders/:OrderId"

	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/orders/:OrderId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/orders/:OrderId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/orders/:OrderId"))
    .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}}/orders/:OrderId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/orders/:OrderId")
  .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}}/orders/:OrderId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/orders/:OrderId'};

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

const url = '{{baseUrl}}/orders/:OrderId';
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}}/orders/:OrderId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/orders/:OrderId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/orders/:OrderId',
  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}}/orders/:OrderId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/orders/:OrderId');

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}}/orders/:OrderId'};

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

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

const url = '{{baseUrl}}/orders/:OrderId';
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}}/orders/:OrderId"]
                                                       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}}/orders/:OrderId" in

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

 "{{baseUrl}}/orders/:OrderId",
  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}}/orders/:OrderId');

echo $response->getBody();

setUrl('{{baseUrl}}/orders/:OrderId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/orders/:OrderId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/orders/:OrderId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/orders/:OrderId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/orders/:OrderId")

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

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

import requests

url = "{{baseUrl}}/orders/:OrderId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/orders/:OrderId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/orders/:OrderId")

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/orders/:OrderId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/orders/:OrderId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/orders/:OrderId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/orders/:OrderId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/outposts/:OutpostId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/outposts/:OutpostId")

require "http/client"

url = "{{baseUrl}}/outposts/:OutpostId"

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}}/outposts/:OutpostId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/outposts/:OutpostId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts/:OutpostId"

	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/outposts/:OutpostId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/outposts/:OutpostId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts/:OutpostId"))
    .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}}/outposts/:OutpostId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/outposts/:OutpostId")
  .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}}/outposts/:OutpostId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/outposts/:OutpostId'};

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

const url = '{{baseUrl}}/outposts/:OutpostId';
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}}/outposts/:OutpostId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts/:OutpostId',
  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}}/outposts/:OutpostId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/outposts/:OutpostId');

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}}/outposts/:OutpostId'};

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

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

const url = '{{baseUrl}}/outposts/:OutpostId';
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}}/outposts/:OutpostId"]
                                                       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}}/outposts/:OutpostId" in

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

 "{{baseUrl}}/outposts/:OutpostId",
  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}}/outposts/:OutpostId');

echo $response->getBody();

setUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/outposts/:OutpostId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts/:OutpostId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/outposts/:OutpostId")

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

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

import requests

url = "{{baseUrl}}/outposts/:OutpostId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts/:OutpostId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts/:OutpostId")

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/outposts/:OutpostId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/outposts/:OutpostId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/outposts/:OutpostId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts/:OutpostId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/outposts/:OutpostId/instanceTypes");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/outposts/:OutpostId/instanceTypes")

require "http/client"

url = "{{baseUrl}}/outposts/:OutpostId/instanceTypes"

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}}/outposts/:OutpostId/instanceTypes"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/outposts/:OutpostId/instanceTypes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts/:OutpostId/instanceTypes"

	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/outposts/:OutpostId/instanceTypes HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/outposts/:OutpostId/instanceTypes")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts/:OutpostId/instanceTypes"))
    .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}}/outposts/:OutpostId/instanceTypes")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/outposts/:OutpostId/instanceTypes")
  .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}}/outposts/:OutpostId/instanceTypes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/outposts/:OutpostId/instanceTypes'
};

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

const url = '{{baseUrl}}/outposts/:OutpostId/instanceTypes';
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}}/outposts/:OutpostId/instanceTypes',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId/instanceTypes")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts/:OutpostId/instanceTypes',
  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}}/outposts/:OutpostId/instanceTypes'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/outposts/:OutpostId/instanceTypes');

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}}/outposts/:OutpostId/instanceTypes'
};

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

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

const url = '{{baseUrl}}/outposts/:OutpostId/instanceTypes';
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}}/outposts/:OutpostId/instanceTypes"]
                                                       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}}/outposts/:OutpostId/instanceTypes" in

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

 "{{baseUrl}}/outposts/:OutpostId/instanceTypes",
  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}}/outposts/:OutpostId/instanceTypes');

echo $response->getBody();

setUrl('{{baseUrl}}/outposts/:OutpostId/instanceTypes');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/outposts/:OutpostId/instanceTypes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/outposts/:OutpostId/instanceTypes' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts/:OutpostId/instanceTypes' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/outposts/:OutpostId/instanceTypes")

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

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

import requests

url = "{{baseUrl}}/outposts/:OutpostId/instanceTypes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts/:OutpostId/instanceTypes"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts/:OutpostId/instanceTypes")

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/outposts/:OutpostId/instanceTypes') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/outposts/:OutpostId/instanceTypes";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/outposts/:OutpostId/instanceTypes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/outposts/:OutpostId/instanceTypes

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts/:OutpostId/instanceTypes")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sites/:SiteId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/sites/:SiteId")

require "http/client"

url = "{{baseUrl}}/sites/:SiteId"

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}}/sites/:SiteId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sites/:SiteId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId"

	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/sites/:SiteId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sites/:SiteId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId"))
    .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}}/sites/:SiteId")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/sites/:SiteId")
  .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}}/sites/:SiteId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/sites/:SiteId'};

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

const url = '{{baseUrl}}/sites/:SiteId';
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}}/sites/:SiteId',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites/:SiteId',
  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}}/sites/:SiteId'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sites/:SiteId');

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}}/sites/:SiteId'};

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

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

const url = '{{baseUrl}}/sites/:SiteId';
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}}/sites/:SiteId"]
                                                       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}}/sites/:SiteId" in

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

 "{{baseUrl}}/sites/:SiteId",
  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}}/sites/:SiteId');

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/sites/:SiteId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sites/:SiteId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/sites/:SiteId")

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites/:SiteId")

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/sites/:SiteId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/sites/:SiteId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/sites/:SiteId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/sites/:SiteId/address#AddressType" {:query-params {:AddressType ""}})

require "http/client"

url = "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType"

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}}/sites/:SiteId/address?AddressType=#AddressType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType"

	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/sites/:SiteId/address?AddressType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType"))
    .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}}/sites/:SiteId/address?AddressType=#AddressType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType")
  .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}}/sites/:SiteId/address?AddressType=#AddressType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/sites/:SiteId/address#AddressType',
  params: {AddressType: ''}
};

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

const url = '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType';
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}}/sites/:SiteId/address?AddressType=#AddressType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites/:SiteId/address?AddressType=',
  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}}/sites/:SiteId/address#AddressType',
  qs: {AddressType: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sites/:SiteId/address#AddressType');

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

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}}/sites/:SiteId/address#AddressType',
  params: {AddressType: ''}
};

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

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

const url = '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType';
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}}/sites/:SiteId/address?AddressType=#AddressType"]
                                                       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}}/sites/:SiteId/address?AddressType=#AddressType" in

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

 "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType",
  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}}/sites/:SiteId/address?AddressType=#AddressType');

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId/address#AddressType');
$request->setMethod(HTTP_METH_GET);

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

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

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

setRequestUrl('{{baseUrl}}/sites/:SiteId/address#AddressType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'AddressType' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/sites/:SiteId/address?AddressType=")

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId/address#AddressType"

querystring = {"AddressType":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId/address#AddressType"

queryString <- list(AddressType = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType")

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/sites/:SiteId/address') do |req|
  req.params['AddressType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/sites/:SiteId/address#AddressType";

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

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

    dbg!(results);
}

http GET '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId/address?AddressType=#AddressType")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/outposts/:OutpostId/assets");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/outposts/:OutpostId/assets")

require "http/client"

url = "{{baseUrl}}/outposts/:OutpostId/assets"

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}}/outposts/:OutpostId/assets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/outposts/:OutpostId/assets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts/:OutpostId/assets"

	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/outposts/:OutpostId/assets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/outposts/:OutpostId/assets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts/:OutpostId/assets"))
    .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}}/outposts/:OutpostId/assets")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/outposts/:OutpostId/assets")
  .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}}/outposts/:OutpostId/assets');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/outposts/:OutpostId/assets'};

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

const url = '{{baseUrl}}/outposts/:OutpostId/assets';
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}}/outposts/:OutpostId/assets',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId/assets")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts/:OutpostId/assets',
  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}}/outposts/:OutpostId/assets'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/outposts/:OutpostId/assets');

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}}/outposts/:OutpostId/assets'};

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

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

const url = '{{baseUrl}}/outposts/:OutpostId/assets';
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}}/outposts/:OutpostId/assets"]
                                                       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}}/outposts/:OutpostId/assets" in

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

 "{{baseUrl}}/outposts/:OutpostId/assets",
  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}}/outposts/:OutpostId/assets');

echo $response->getBody();

setUrl('{{baseUrl}}/outposts/:OutpostId/assets');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/outposts/:OutpostId/assets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/outposts/:OutpostId/assets' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts/:OutpostId/assets' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/outposts/:OutpostId/assets")

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

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

import requests

url = "{{baseUrl}}/outposts/:OutpostId/assets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts/:OutpostId/assets"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts/:OutpostId/assets")

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/outposts/:OutpostId/assets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/outposts/:OutpostId/assets";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/outposts/:OutpostId/assets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/outposts/:OutpostId/assets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts/:OutpostId/assets")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/catalog/items");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/catalog/items")

require "http/client"

url = "{{baseUrl}}/catalog/items"

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}}/catalog/items"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/catalog/items");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/catalog/items"

	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/catalog/items HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/catalog/items")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/catalog/items"))
    .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}}/catalog/items")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/catalog/items")
  .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}}/catalog/items');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/catalog/items'};

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

const url = '{{baseUrl}}/catalog/items';
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}}/catalog/items',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/catalog/items")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/catalog/items',
  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}}/catalog/items'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/catalog/items');

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}}/catalog/items'};

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

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

const url = '{{baseUrl}}/catalog/items';
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}}/catalog/items"]
                                                       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}}/catalog/items" in

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

 "{{baseUrl}}/catalog/items",
  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}}/catalog/items');

echo $response->getBody();

setUrl('{{baseUrl}}/catalog/items');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/catalog/items');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/catalog/items' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/catalog/items' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/catalog/items")

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

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

import requests

url = "{{baseUrl}}/catalog/items"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/catalog/items"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/catalog/items")

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/catalog/items') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/catalog/items

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/catalog/items

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/catalog/items")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/list-orders");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/list-orders")

require "http/client"

url = "{{baseUrl}}/list-orders"

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}}/list-orders"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/list-orders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/list-orders"

	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/list-orders HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/list-orders")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/list-orders"))
    .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}}/list-orders")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/list-orders")
  .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}}/list-orders');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/list-orders'};

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

const url = '{{baseUrl}}/list-orders';
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}}/list-orders',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/list-orders")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/list-orders',
  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}}/list-orders'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/list-orders');

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}}/list-orders'};

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

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

const url = '{{baseUrl}}/list-orders';
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}}/list-orders"]
                                                       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}}/list-orders" in

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

 "{{baseUrl}}/list-orders",
  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}}/list-orders');

echo $response->getBody();

setUrl('{{baseUrl}}/list-orders');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/list-orders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/list-orders' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/list-orders' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/list-orders")

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

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

import requests

url = "{{baseUrl}}/list-orders"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/list-orders"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/list-orders")

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/list-orders') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/list-orders

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/list-orders

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/list-orders")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/outposts");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/outposts")

require "http/client"

url = "{{baseUrl}}/outposts"

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}}/outposts"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/outposts");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/outposts"

	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/outposts HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/outposts")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts"))
    .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}}/outposts")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/outposts")
  .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}}/outposts');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/outposts'};

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

const url = '{{baseUrl}}/outposts';
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}}/outposts',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/outposts")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts',
  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}}/outposts'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/outposts');

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}}/outposts'};

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

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

const url = '{{baseUrl}}/outposts';
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}}/outposts"]
                                                       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}}/outposts" in

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

 "{{baseUrl}}/outposts",
  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}}/outposts');

echo $response->getBody();

setUrl('{{baseUrl}}/outposts');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/outposts');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/outposts' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/outposts")

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

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

import requests

url = "{{baseUrl}}/outposts"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts")

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/outposts') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/outposts

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/outposts

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sites");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/sites")

require "http/client"

url = "{{baseUrl}}/sites"

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}}/sites"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/sites");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites"

	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/sites HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sites")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites"))
    .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}}/sites")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/sites")
  .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}}/sites');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/sites'};

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

const url = '{{baseUrl}}/sites';
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}}/sites',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/sites")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites',
  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}}/sites'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/sites');

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}}/sites'};

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

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

const url = '{{baseUrl}}/sites';
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}}/sites"]
                                                       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}}/sites" in

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

 "{{baseUrl}}/sites",
  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}}/sites');

echo $response->getBody();

setUrl('{{baseUrl}}/sites');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/sites');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/sites' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/sites")

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

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

import requests

url = "{{baseUrl}}/sites"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites")

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/sites') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/sites

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/sites

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:ResourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/tags/:ResourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:ResourceArn"

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}}/tags/:ResourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:ResourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:ResourceArn"

	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/tags/:ResourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:ResourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:ResourceArn"))
    .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}}/tags/:ResourceArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:ResourceArn")
  .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}}/tags/:ResourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:ResourceArn'};

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

const url = '{{baseUrl}}/tags/:ResourceArn';
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}}/tags/:ResourceArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:ResourceArn")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:ResourceArn',
  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}}/tags/:ResourceArn'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:ResourceArn');

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}}/tags/:ResourceArn'};

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

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

const url = '{{baseUrl}}/tags/:ResourceArn';
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}}/tags/:ResourceArn"]
                                                       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}}/tags/:ResourceArn" in

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

 "{{baseUrl}}/tags/:ResourceArn",
  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}}/tags/:ResourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:ResourceArn');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/tags/:ResourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:ResourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:ResourceArn' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/tags/:ResourceArn")

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

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

import requests

url = "{{baseUrl}}/tags/:ResourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:ResourceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:ResourceArn")

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/tags/:ResourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

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

    dbg!(results);
}

http GET {{baseUrl}}/tags/:ResourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:ResourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:ResourceArn")! 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}}/connections");

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  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/connections" {:content-type :json
                                                        :form-params {:DeviceSerialNumber ""
                                                                      :AssetId ""
                                                                      :ClientPublicKey ""
                                                                      :NetworkInterfaceDeviceIndex 0}})

require "http/client"

url = "{{baseUrl}}/connections"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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}}/connections"),
    Content = new StringContent("{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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}}/connections");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/connections"

	payload := strings.NewReader("{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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/connections HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/connections")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connections"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/connections")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/connections")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}")
  .asString();

const data = JSON.stringify({
  DeviceSerialNumber: '',
  AssetId: '',
  ClientPublicKey: '',
  NetworkInterfaceDeviceIndex: 0
});

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

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

xhr.open('POST', '{{baseUrl}}/connections');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connections',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceSerialNumber: '',
    AssetId: '',
    ClientPublicKey: '',
    NetworkInterfaceDeviceIndex: 0
  }
};

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

const url = '{{baseUrl}}/connections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceSerialNumber":"","AssetId":"","ClientPublicKey":"","NetworkInterfaceDeviceIndex":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/connections',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceSerialNumber": "",\n  "AssetId": "",\n  "ClientPublicKey": "",\n  "NetworkInterfaceDeviceIndex": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/connections")
  .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/connections',
  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({
  DeviceSerialNumber: '',
  AssetId: '',
  ClientPublicKey: '',
  NetworkInterfaceDeviceIndex: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connections',
  headers: {'content-type': 'application/json'},
  body: {
    DeviceSerialNumber: '',
    AssetId: '',
    ClientPublicKey: '',
    NetworkInterfaceDeviceIndex: 0
  },
  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}}/connections');

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

req.type('json');
req.send({
  DeviceSerialNumber: '',
  AssetId: '',
  ClientPublicKey: '',
  NetworkInterfaceDeviceIndex: 0
});

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}}/connections',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceSerialNumber: '',
    AssetId: '',
    ClientPublicKey: '',
    NetworkInterfaceDeviceIndex: 0
  }
};

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

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

const url = '{{baseUrl}}/connections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceSerialNumber":"","AssetId":"","ClientPublicKey":"","NetworkInterfaceDeviceIndex":0}'
};

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 = @{ @"DeviceSerialNumber": @"",
                              @"AssetId": @"",
                              @"ClientPublicKey": @"",
                              @"NetworkInterfaceDeviceIndex": @0 };

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

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

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

 "{{baseUrl}}/connections",
  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([
    'DeviceSerialNumber' => '',
    'AssetId' => '',
    'ClientPublicKey' => '',
    'NetworkInterfaceDeviceIndex' => 0
  ]),
  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}}/connections', [
  'body' => '{
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/connections');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceSerialNumber' => '',
  'AssetId' => '',
  'ClientPublicKey' => '',
  'NetworkInterfaceDeviceIndex' => 0
]));

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

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

append(json_encode([
  'DeviceSerialNumber' => '',
  'AssetId' => '',
  'ClientPublicKey' => '',
  'NetworkInterfaceDeviceIndex' => 0
]));
$request->setRequestUrl('{{baseUrl}}/connections');
$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}}/connections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/connections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
}'

import http.client

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

payload = "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/connections"

payload = {
    "DeviceSerialNumber": "",
    "AssetId": "",
    "ClientPublicKey": "",
    "NetworkInterfaceDeviceIndex": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/connections"

payload <- "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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}}/connections")

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  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\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/connections') do |req|
  req.body = "{\n  \"DeviceSerialNumber\": \"\",\n  \"AssetId\": \"\",\n  \"ClientPublicKey\": \"\",\n  \"NetworkInterfaceDeviceIndex\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "DeviceSerialNumber": "",
        "AssetId": "",
        "ClientPublicKey": "",
        "NetworkInterfaceDeviceIndex": 0
    });

    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 '{
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
}' |  \
  http POST {{baseUrl}}/connections \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceSerialNumber": "",\n  "AssetId": "",\n  "ClientPublicKey": "",\n  "NetworkInterfaceDeviceIndex": 0\n}' \
  --output-document \
  - {{baseUrl}}/connections

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DeviceSerialNumber": "",
  "AssetId": "",
  "ClientPublicKey": "",
  "NetworkInterfaceDeviceIndex": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connections")! 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}}/tags/:ResourceArn");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/tags/:ResourceArn" {:content-type :json
                                                              :form-params {:Tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:ResourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/tags/:ResourceArn"),
    Content = new StringContent("{\n  \"Tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:ResourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:ResourceArn"

	payload := strings.NewReader("{\n  \"Tags\": {}\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/tags/:ResourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "Tags": {}
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:ResourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:ResourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:ResourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"Tags\": {}\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:ResourceArn',
  headers: {'content-type': 'application/json'},
  data: {Tags: {}}
};

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

const url = '{{baseUrl}}/tags/:ResourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:ResourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:ResourceArn")
  .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/tags/:ResourceArn',
  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({Tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:ResourceArn',
  headers: {'content-type': 'application/json'},
  body: {Tags: {}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/tags/:ResourceArn');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:ResourceArn',
  headers: {'content-type': 'application/json'},
  data: {Tags: {}}
};

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

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

const url = '{{baseUrl}}/tags/:ResourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Tags":{}}'
};

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

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

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

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

 "{{baseUrl}}/tags/:ResourceArn",
  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([
    'Tags' => [
        
    ]
  ]),
  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}}/tags/:ResourceArn', [
  'body' => '{
  "Tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:ResourceArn');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:ResourceArn');
$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}}/tags/:ResourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:ResourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Tags": {}
}'

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/tags/:ResourceArn"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:ResourceArn"

payload <- "{\n  \"Tags\": {}\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}}/tags/:ResourceArn")

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

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

require 'faraday'

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

response = conn.post('/baseUrl/tags/:ResourceArn') do |req|
  req.body = "{\n  \"Tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "Tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:ResourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:ResourceArn

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:ResourceArn")! 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}}/tags/:ResourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/tags/:ResourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys"

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}}/tags/:ResourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys"

	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/tags/:ResourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys"))
    .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}}/tags/:ResourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys")
  .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}}/tags/:ResourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:ResourceArn#tagKeys',
  params: {tagKeys: ''}
};

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

const url = '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys';
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}}/tags/:ResourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:ResourceArn?tagKeys=',
  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}}/tags/:ResourceArn#tagKeys',
  qs: {tagKeys: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:ResourceArn#tagKeys');

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

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:ResourceArn#tagKeys',
  params: {tagKeys: ''}
};

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

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

const url = '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys';
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}}/tags/:ResourceArn?tagKeys=#tagKeys"]
                                                       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}}/tags/:ResourceArn?tagKeys=#tagKeys" in

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

 "{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys",
  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}}/tags/:ResourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:ResourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

setRequestUrl('{{baseUrl}}/tags/:ResourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/tags/:ResourceArn?tagKeys=")

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

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

import requests

url = "{{baseUrl}}/tags/:ResourceArn#tagKeys"

querystring = {"tagKeys":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:ResourceArn#tagKeys"

queryString <- list(tagKeys = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys")

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/tags/:ResourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:ResourceArn#tagKeys";

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

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

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

    dbg!(results);
}

http DELETE '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:ResourceArn?tagKeys=#tagKeys")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/outposts/:OutpostId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/outposts/:OutpostId" {:content-type :json
                                                                 :form-params {:Name ""
                                                                               :Description ""
                                                                               :SupportedHardwareType ""}})

require "http/client"

url = "{{baseUrl}}/outposts/:OutpostId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/outposts/:OutpostId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/outposts/:OutpostId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/outposts/:OutpostId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/outposts/:OutpostId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/outposts/:OutpostId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  SupportedHardwareType: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/outposts/:OutpostId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/outposts/:OutpostId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', SupportedHardwareType: ''}
};

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

const url = '{{baseUrl}}/outposts/:OutpostId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","SupportedHardwareType":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/outposts/:OutpostId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "SupportedHardwareType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/outposts/:OutpostId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/outposts/:OutpostId',
  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({Name: '', Description: '', SupportedHardwareType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/outposts/:OutpostId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', SupportedHardwareType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/outposts/:OutpostId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  SupportedHardwareType: ''
});

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}}/outposts/:OutpostId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', SupportedHardwareType: ''}
};

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

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

const url = '{{baseUrl}}/outposts/:OutpostId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","SupportedHardwareType":""}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"SupportedHardwareType": @"" };

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

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

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

 "{{baseUrl}}/outposts/:OutpostId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'SupportedHardwareType' => ''
  ]),
  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('PATCH', '{{baseUrl}}/outposts/:OutpostId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'SupportedHardwareType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/outposts/:OutpostId');
$request->setRequestMethod('PATCH');
$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}}/outposts/:OutpostId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/outposts/:OutpostId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/outposts/:OutpostId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/outposts/:OutpostId"

payload = {
    "Name": "",
    "Description": "",
    "SupportedHardwareType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/outposts/:OutpostId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/outposts/:OutpostId")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\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.patch('/baseUrl/outposts/:OutpostId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"SupportedHardwareType\": \"\"\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}}/outposts/:OutpostId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "SupportedHardwareType": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
}' |  \
  http PATCH {{baseUrl}}/outposts/:OutpostId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "SupportedHardwareType": ""\n}' \
  --output-document \
  - {{baseUrl}}/outposts/:OutpostId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "SupportedHardwareType": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/outposts/:OutpostId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sites/:SiteId");

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  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/sites/:SiteId" {:content-type :json
                                                           :form-params {:Name ""
                                                                         :Description ""
                                                                         :Notes ""}})

require "http/client"

url = "{{baseUrl}}/sites/:SiteId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/sites/:SiteId HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "Name": "",
  "Description": "",
  "Notes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/sites/:SiteId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/sites/:SiteId")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Description: '',
  Notes: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/sites/:SiteId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/sites/:SiteId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', Notes: ''}
};

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

const url = '{{baseUrl}}/sites/:SiteId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Notes":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/sites/:SiteId',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Description": "",\n  "Notes": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites/:SiteId',
  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({Name: '', Description: '', Notes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/sites/:SiteId',
  headers: {'content-type': 'application/json'},
  body: {Name: '', Description: '', Notes: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/sites/:SiteId');

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

req.type('json');
req.send({
  Name: '',
  Description: '',
  Notes: ''
});

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}}/sites/:SiteId',
  headers: {'content-type': 'application/json'},
  data: {Name: '', Description: '', Notes: ''}
};

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

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

const url = '{{baseUrl}}/sites/:SiteId';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","Description":"","Notes":""}'
};

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 = @{ @"Name": @"",
                              @"Description": @"",
                              @"Notes": @"" };

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

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

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

 "{{baseUrl}}/sites/:SiteId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Description' => '',
    'Notes' => ''
  ]),
  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('PATCH', '{{baseUrl}}/sites/:SiteId', [
  'body' => '{
  "Name": "",
  "Description": "",
  "Notes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

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

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

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

append(json_encode([
  'Name' => '',
  'Description' => '',
  'Notes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/sites/:SiteId');
$request->setRequestMethod('PATCH');
$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}}/sites/:SiteId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Notes": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Description": "",
  "Notes": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/sites/:SiteId", payload, headers)

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId"

payload = {
    "Name": "",
    "Description": "",
    "Notes": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId"

payload <- "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites/:SiteId")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\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.patch('/baseUrl/sites/:SiteId') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"Description\": \"\",\n  \"Notes\": \"\"\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}}/sites/:SiteId";

    let payload = json!({
        "Name": "",
        "Description": "",
        "Notes": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "Name": "",
  "Description": "",
  "Notes": ""
}' |  \
  http PATCH {{baseUrl}}/sites/:SiteId \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Description": "",\n  "Notes": ""\n}' \
  --output-document \
  - {{baseUrl}}/sites/:SiteId

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "Description": "",
  "Notes": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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}}/sites/:SiteId/address");

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  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/sites/:SiteId/address" {:content-type :json
                                                                 :form-params {:AddressType ""
                                                                               :Address {:ContactName ""
                                                                                         :ContactPhoneNumber ""
                                                                                         :AddressLine1 ""
                                                                                         :AddressLine2 ""
                                                                                         :AddressLine3 ""
                                                                                         :City ""
                                                                                         :StateOrRegion ""
                                                                                         :DistrictOrCounty ""
                                                                                         :PostalCode ""
                                                                                         :CountryCode ""
                                                                                         :Municipality ""}}})

require "http/client"

url = "{{baseUrl}}/sites/:SiteId/address"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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}}/sites/:SiteId/address"),
    Content = new StringContent("{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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}}/sites/:SiteId/address");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId/address"

	payload := strings.NewReader("{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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/sites/:SiteId/address HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 305

{
  "AddressType": "",
  "Address": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/sites/:SiteId/address")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId/address"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId/address")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/sites/:SiteId/address")
  .header("content-type", "application/json")
  .body("{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  AddressType: '',
  Address: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/sites/:SiteId/address');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/sites/:SiteId/address',
  headers: {'content-type': 'application/json'},
  data: {
    AddressType: '',
    Address: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    }
  }
};

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

const url = '{{baseUrl}}/sites/:SiteId/address';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AddressType":"","Address":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/sites/:SiteId/address',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AddressType": "",\n  "Address": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\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  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId/address")
  .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/sites/:SiteId/address',
  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({
  AddressType: '',
  Address: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  }
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/sites/:SiteId/address',
  headers: {'content-type': 'application/json'},
  body: {
    AddressType: '',
    Address: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    }
  },
  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}}/sites/:SiteId/address');

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

req.type('json');
req.send({
  AddressType: '',
  Address: {
    ContactName: '',
    ContactPhoneNumber: '',
    AddressLine1: '',
    AddressLine2: '',
    AddressLine3: '',
    City: '',
    StateOrRegion: '',
    DistrictOrCounty: '',
    PostalCode: '',
    CountryCode: '',
    Municipality: ''
  }
});

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}}/sites/:SiteId/address',
  headers: {'content-type': 'application/json'},
  data: {
    AddressType: '',
    Address: {
      ContactName: '',
      ContactPhoneNumber: '',
      AddressLine1: '',
      AddressLine2: '',
      AddressLine3: '',
      City: '',
      StateOrRegion: '',
      DistrictOrCounty: '',
      PostalCode: '',
      CountryCode: '',
      Municipality: ''
    }
  }
};

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

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

const url = '{{baseUrl}}/sites/:SiteId/address';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"AddressType":"","Address":{"ContactName":"","ContactPhoneNumber":"","AddressLine1":"","AddressLine2":"","AddressLine3":"","City":"","StateOrRegion":"","DistrictOrCounty":"","PostalCode":"","CountryCode":"","Municipality":""}}'
};

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 = @{ @"AddressType": @"",
                              @"Address": @{ @"ContactName": @"", @"ContactPhoneNumber": @"", @"AddressLine1": @"", @"AddressLine2": @"", @"AddressLine3": @"", @"City": @"", @"StateOrRegion": @"", @"DistrictOrCounty": @"", @"PostalCode": @"", @"CountryCode": @"", @"Municipality": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sites/:SiteId/address"]
                                                       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}}/sites/:SiteId/address" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/sites/:SiteId/address",
  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([
    'AddressType' => '',
    'Address' => [
        'ContactName' => '',
        'ContactPhoneNumber' => '',
        'AddressLine1' => '',
        'AddressLine2' => '',
        'AddressLine3' => '',
        'City' => '',
        'StateOrRegion' => '',
        'DistrictOrCounty' => '',
        'PostalCode' => '',
        'CountryCode' => '',
        'Municipality' => ''
    ]
  ]),
  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}}/sites/:SiteId/address', [
  'body' => '{
  "AddressType": "",
  "Address": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId/address');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AddressType' => '',
  'Address' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ]
]));

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

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

append(json_encode([
  'AddressType' => '',
  'Address' => [
    'ContactName' => '',
    'ContactPhoneNumber' => '',
    'AddressLine1' => '',
    'AddressLine2' => '',
    'AddressLine3' => '',
    'City' => '',
    'StateOrRegion' => '',
    'DistrictOrCounty' => '',
    'PostalCode' => '',
    'CountryCode' => '',
    'Municipality' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/sites/:SiteId/address');
$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}}/sites/:SiteId/address' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AddressType": "",
  "Address": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId/address' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "AddressType": "",
  "Address": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  }
}'

import http.client

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

payload = "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\n  }\n}"

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

conn.request("PUT", "/baseUrl/sites/:SiteId/address", payload, headers)

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId/address"

payload = {
    "AddressType": "",
    "Address": {
        "ContactName": "",
        "ContactPhoneNumber": "",
        "AddressLine1": "",
        "AddressLine2": "",
        "AddressLine3": "",
        "City": "",
        "StateOrRegion": "",
        "DistrictOrCounty": "",
        "PostalCode": "",
        "CountryCode": "",
        "Municipality": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId/address"

payload <- "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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}}/sites/:SiteId/address")

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  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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/sites/:SiteId/address') do |req|
  req.body = "{\n  \"AddressType\": \"\",\n  \"Address\": {\n    \"ContactName\": \"\",\n    \"ContactPhoneNumber\": \"\",\n    \"AddressLine1\": \"\",\n    \"AddressLine2\": \"\",\n    \"AddressLine3\": \"\",\n    \"City\": \"\",\n    \"StateOrRegion\": \"\",\n    \"DistrictOrCounty\": \"\",\n    \"PostalCode\": \"\",\n    \"CountryCode\": \"\",\n    \"Municipality\": \"\"\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}}/sites/:SiteId/address";

    let payload = json!({
        "AddressType": "",
        "Address": json!({
            "ContactName": "",
            "ContactPhoneNumber": "",
            "AddressLine1": "",
            "AddressLine2": "",
            "AddressLine3": "",
            "City": "",
            "StateOrRegion": "",
            "DistrictOrCounty": "",
            "PostalCode": "",
            "CountryCode": "",
            "Municipality": ""
        })
    });

    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 '{
  "AddressType": "",
  "Address": {
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  }
}' |  \
  http PUT {{baseUrl}}/sites/:SiteId/address \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "AddressType": "",\n  "Address": {\n    "ContactName": "",\n    "ContactPhoneNumber": "",\n    "AddressLine1": "",\n    "AddressLine2": "",\n    "AddressLine3": "",\n    "City": "",\n    "StateOrRegion": "",\n    "DistrictOrCounty": "",\n    "PostalCode": "",\n    "CountryCode": "",\n    "Municipality": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/sites/:SiteId/address

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AddressType": "",
  "Address": [
    "ContactName": "",
    "ContactPhoneNumber": "",
    "AddressLine1": "",
    "AddressLine2": "",
    "AddressLine3": "",
    "City": "",
    "StateOrRegion": "",
    "DistrictOrCounty": "",
    "PostalCode": "",
    "CountryCode": "",
    "Municipality": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId/address")! 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, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties");

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  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties" {:content-type :json
                                                                                  :form-params {:PowerDrawKva ""
                                                                                                :PowerPhase ""
                                                                                                :PowerConnector ""
                                                                                                :PowerFeedDrop ""
                                                                                                :UplinkGbps ""
                                                                                                :UplinkCount ""
                                                                                                :FiberOpticCableType ""
                                                                                                :OpticalStandard ""
                                                                                                :MaximumSupportedWeightLbs ""}})

require "http/client"

url = "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"),
    Content = new StringContent("{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\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}}/sites/:SiteId/rackPhysicalProperties");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"

	payload := strings.NewReader("{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", 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))

}

PATCH /baseUrl/sites/:SiteId/rackPhysicalProperties HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 221

{
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\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  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")
  .header("content-type", "application/json")
  .body("{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PowerDrawKva: '',
  PowerPhase: '',
  PowerConnector: '',
  PowerFeedDrop: '',
  UplinkGbps: '',
  UplinkCount: '',
  FiberOpticCableType: '',
  OpticalStandard: '',
  MaximumSupportedWeightLbs: ''
});

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

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

xhr.open('PATCH', '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties',
  headers: {'content-type': 'application/json'},
  data: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  }
};

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

const url = '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"PowerDrawKva":"","PowerPhase":"","PowerConnector":"","PowerFeedDrop":"","UplinkGbps":"","UplinkCount":"","FiberOpticCableType":"","OpticalStandard":"","MaximumSupportedWeightLbs":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PowerDrawKva": "",\n  "PowerPhase": "",\n  "PowerConnector": "",\n  "PowerFeedDrop": "",\n  "UplinkGbps": "",\n  "UplinkCount": "",\n  "FiberOpticCableType": "",\n  "OpticalStandard": "",\n  "MaximumSupportedWeightLbs": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/sites/:SiteId/rackPhysicalProperties',
  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({
  PowerDrawKva: '',
  PowerPhase: '',
  PowerConnector: '',
  PowerFeedDrop: '',
  UplinkGbps: '',
  UplinkCount: '',
  FiberOpticCableType: '',
  OpticalStandard: '',
  MaximumSupportedWeightLbs: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties',
  headers: {'content-type': 'application/json'},
  body: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties');

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

req.type('json');
req.send({
  PowerDrawKva: '',
  PowerPhase: '',
  PowerConnector: '',
  PowerFeedDrop: '',
  UplinkGbps: '',
  UplinkCount: '',
  FiberOpticCableType: '',
  OpticalStandard: '',
  MaximumSupportedWeightLbs: ''
});

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}}/sites/:SiteId/rackPhysicalProperties',
  headers: {'content-type': 'application/json'},
  data: {
    PowerDrawKva: '',
    PowerPhase: '',
    PowerConnector: '',
    PowerFeedDrop: '',
    UplinkGbps: '',
    UplinkCount: '',
    FiberOpticCableType: '',
    OpticalStandard: '',
    MaximumSupportedWeightLbs: ''
  }
};

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

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

const url = '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"PowerDrawKva":"","PowerPhase":"","PowerConnector":"","PowerFeedDrop":"","UplinkGbps":"","UplinkCount":"","FiberOpticCableType":"","OpticalStandard":"","MaximumSupportedWeightLbs":""}'
};

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 = @{ @"PowerDrawKva": @"",
                              @"PowerPhase": @"",
                              @"PowerConnector": @"",
                              @"PowerFeedDrop": @"",
                              @"UplinkGbps": @"",
                              @"UplinkCount": @"",
                              @"FiberOpticCableType": @"",
                              @"OpticalStandard": @"",
                              @"MaximumSupportedWeightLbs": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/sites/:SiteId/rackPhysicalProperties" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}" in

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

 "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'PowerDrawKva' => '',
    'PowerPhase' => '',
    'PowerConnector' => '',
    'PowerFeedDrop' => '',
    'UplinkGbps' => '',
    'UplinkCount' => '',
    'FiberOpticCableType' => '',
    'OpticalStandard' => '',
    'MaximumSupportedWeightLbs' => ''
  ]),
  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('PATCH', '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties', [
  'body' => '{
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/sites/:SiteId/rackPhysicalProperties');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PowerDrawKva' => '',
  'PowerPhase' => '',
  'PowerConnector' => '',
  'PowerFeedDrop' => '',
  'UplinkGbps' => '',
  'UplinkCount' => '',
  'FiberOpticCableType' => '',
  'OpticalStandard' => '',
  'MaximumSupportedWeightLbs' => ''
]));

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

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

append(json_encode([
  'PowerDrawKva' => '',
  'PowerPhase' => '',
  'PowerConnector' => '',
  'PowerFeedDrop' => '',
  'UplinkGbps' => '',
  'UplinkCount' => '',
  'FiberOpticCableType' => '',
  'OpticalStandard' => '',
  'MaximumSupportedWeightLbs' => ''
]));
$request->setRequestUrl('{{baseUrl}}/sites/:SiteId/rackPhysicalProperties');
$request->setRequestMethod('PATCH');
$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}}/sites/:SiteId/rackPhysicalProperties' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/sites/:SiteId/rackPhysicalProperties' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
}'

import http.client

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

payload = "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/sites/:SiteId/rackPhysicalProperties", payload, headers)

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

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

import requests

url = "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"

payload = {
    "PowerDrawKva": "",
    "PowerPhase": "",
    "PowerConnector": "",
    "PowerFeedDrop": "",
    "UplinkGbps": "",
    "UplinkCount": "",
    "FiberOpticCableType": "",
    "OpticalStandard": "",
    "MaximumSupportedWeightLbs": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties"

payload <- "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\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.patch('/baseUrl/sites/:SiteId/rackPhysicalProperties') do |req|
  req.body = "{\n  \"PowerDrawKva\": \"\",\n  \"PowerPhase\": \"\",\n  \"PowerConnector\": \"\",\n  \"PowerFeedDrop\": \"\",\n  \"UplinkGbps\": \"\",\n  \"UplinkCount\": \"\",\n  \"FiberOpticCableType\": \"\",\n  \"OpticalStandard\": \"\",\n  \"MaximumSupportedWeightLbs\": \"\"\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}}/sites/:SiteId/rackPhysicalProperties";

    let payload = json!({
        "PowerDrawKva": "",
        "PowerPhase": "",
        "PowerConnector": "",
        "PowerFeedDrop": "",
        "UplinkGbps": "",
        "UplinkCount": "",
        "FiberOpticCableType": "",
        "OpticalStandard": "",
        "MaximumSupportedWeightLbs": ""
    });

    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("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
}' |  \
  http PATCH {{baseUrl}}/sites/:SiteId/rackPhysicalProperties \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "PowerDrawKva": "",\n  "PowerPhase": "",\n  "PowerConnector": "",\n  "PowerFeedDrop": "",\n  "UplinkGbps": "",\n  "UplinkCount": "",\n  "FiberOpticCableType": "",\n  "OpticalStandard": "",\n  "MaximumSupportedWeightLbs": ""\n}' \
  --output-document \
  - {{baseUrl}}/sites/:SiteId/rackPhysicalProperties

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "PowerDrawKva": "",
  "PowerPhase": "",
  "PowerConnector": "",
  "PowerFeedDrop": "",
  "UplinkGbps": "",
  "UplinkCount": "",
  "FiberOpticCableType": "",
  "OpticalStandard": "",
  "MaximumSupportedWeightLbs": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sites/:SiteId/rackPhysicalProperties")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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()