AWS IoT SiteWisev2019-12-02

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/assets/:assetId/associate");

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  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/assets/:assetId/associate" {:content-type :json
                                                                      :form-params {:hierarchyId ""
                                                                                    :childAssetId ""
                                                                                    :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/assets/:assetId/associate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/:assetId/associate"),
    Content = new StringContent("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/associate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/assets/:assetId/associate"

	payload := strings.NewReader("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\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/assets/:assetId/associate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/:assetId/associate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/associate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/associate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/assets/:assetId/associate")
  .header("content-type", "application/json")
  .body("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  hierarchyId: '',
  childAssetId: '',
  clientToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/assets/:assetId/associate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/associate',
  headers: {'content-type': 'application/json'},
  data: {hierarchyId: '', childAssetId: '', clientToken: ''}
};

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

const url = '{{baseUrl}}/assets/:assetId/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hierarchyId":"","childAssetId":"","clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/:assetId/associate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "hierarchyId": "",\n  "childAssetId": "",\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/associate")
  .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/assets/:assetId/associate',
  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({hierarchyId: '', childAssetId: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/associate',
  headers: {'content-type': 'application/json'},
  body: {hierarchyId: '', childAssetId: '', clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/:assetId/associate');

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

req.type('json');
req.send({
  hierarchyId: '',
  childAssetId: '',
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/associate',
  headers: {'content-type': 'application/json'},
  data: {hierarchyId: '', childAssetId: '', clientToken: ''}
};

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

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

const url = '{{baseUrl}}/assets/:assetId/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hierarchyId":"","childAssetId":"","clientToken":""}'
};

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 = @{ @"hierarchyId": @"",
                              @"childAssetId": @"",
                              @"clientToken": @"" };

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

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

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

 "{{baseUrl}}/assets/:assetId/associate",
  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([
    'hierarchyId' => '',
    'childAssetId' => '',
    'clientToken' => ''
  ]),
  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}}/assets/:assetId/associate', [
  'body' => '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/associate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'hierarchyId' => '',
  'childAssetId' => '',
  'clientToken' => ''
]));

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

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

append(json_encode([
  'hierarchyId' => '',
  'childAssetId' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets/:assetId/associate');
$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}}/assets/:assetId/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/assets/:assetId/associate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/assets/:assetId/associate"

payload = {
    "hierarchyId": "",
    "childAssetId": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/associate"

payload <- "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\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}}/assets/:assetId/associate")

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  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/assets/:assetId/associate') do |req|
  req.body = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "hierarchyId": "",
        "childAssetId": "",
        "clientToken": ""
    });

    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 '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/assets/:assetId/associate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "hierarchyId": "",\n  "childAssetId": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets/:assetId/associate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/associate")! 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}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId" {:query-params {:alias ""
                                                                                                          :assetId ""
                                                                                                          :propertyId ""}
                                                                                           :content-type :json
                                                                                           :form-params {:clientToken ""}})

require "http/client"

url = "{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"),
    Content = new StringContent("{\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"

	payload := strings.NewReader("{\n  \"clientToken\": \"\"\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/timeseries/associate/?alias=&assetId=&propertyId= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId',
  params: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

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

const url = '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .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/timeseries/associate/?alias=&assetId=&propertyId=',
  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({clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId',
  qs: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  body: {clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId');

req.query({
  alias: '',
  assetId: '',
  propertyId: ''
});

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId',
  params: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

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

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

const url = '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"]
                                                       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}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => ''
  ]),
  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}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId', [
  'body' => '{
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'alias' => '',
  'assetId' => '',
  'propertyId' => ''
]);

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

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

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

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

append(json_encode([
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'alias' => '',
  'assetId' => '',
  'propertyId' => ''
]));

$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}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/timeseries/associate/?alias=&assetId=&propertyId=", payload, headers)

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

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

import requests

url = "{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId"

querystring = {"alias":"","assetId":"","propertyId":""}

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId"

queryString <- list(
  alias = "",
  assetId = "",
  propertyId = ""
)

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

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")

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

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

require 'faraday'

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

response = conn.post('/baseUrl/timeseries/associate/') do |req|
  req.params['alias'] = ''
  req.params['assetId'] = ''
  req.params['propertyId'] = ''
  req.body = "{\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeseries/associate/#alias&assetId&propertyId";

    let querystring = [
        ("alias", ""),
        ("assetId", ""),
        ("propertyId", ""),
    ];

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

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

echo '{
  "clientToken": ""
}' |  \
  http POST '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeseries/associate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")! 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}}/projects/:projectId/assets/associate");

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  \"assetIds\": [],\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/projects/:projectId/assets/associate" {:content-type :json
                                                                                 :form-params {:assetIds []
                                                                                               :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/projects/:projectId/assets/associate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/projects/:projectId/assets/associate"),
    Content = new StringContent("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:projectId/assets/associate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/assets/associate"

	payload := strings.NewReader("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\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/projects/:projectId/assets/associate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "assetIds": [],
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects/:projectId/assets/associate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:projectId/assets/associate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/assets/associate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/projects/:projectId/assets/associate")
  .header("content-type", "application/json")
  .body("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/projects/:projectId/assets/associate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/associate',
  headers: {'content-type': 'application/json'},
  data: {assetIds: [], clientToken: ''}
};

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

const url = '{{baseUrl}}/projects/:projectId/assets/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetIds":[],"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:projectId/assets/associate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assetIds": [],\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/assets/associate")
  .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/projects/:projectId/assets/associate',
  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({assetIds: [], clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/associate',
  headers: {'content-type': 'application/json'},
  body: {assetIds: [], clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/projects/:projectId/assets/associate');

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

req.type('json');
req.send({
  assetIds: [],
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/associate',
  headers: {'content-type': 'application/json'},
  data: {assetIds: [], clientToken: ''}
};

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

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

const url = '{{baseUrl}}/projects/:projectId/assets/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetIds":[],"clientToken":""}'
};

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 = @{ @"assetIds": @[  ],
                              @"clientToken": @"" };

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

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

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

 "{{baseUrl}}/projects/:projectId/assets/associate",
  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([
    'assetIds' => [
        
    ],
    'clientToken' => ''
  ]),
  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}}/projects/:projectId/assets/associate', [
  'body' => '{
  "assetIds": [],
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/assets/associate');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'assetIds' => [
    
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/projects/:projectId/assets/associate');
$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}}/projects/:projectId/assets/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetIds": [],
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/assets/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetIds": [],
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/projects/:projectId/assets/associate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/assets/associate"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/assets/associate"

payload <- "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\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}}/projects/:projectId/assets/associate")

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  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/projects/:projectId/assets/associate') do |req|
  req.body = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "assetIds": (),
        "clientToken": ""
    });

    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 '{
  "assetIds": [],
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/projects/:projectId/assets/associate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assetIds": [],\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/projects/:projectId/assets/associate

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:projectId/assets/associate")! 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}}/projects/:projectId/assets/disassociate");

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  \"assetIds\": [],\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/projects/:projectId/assets/disassociate" {:content-type :json
                                                                                    :form-params {:assetIds []
                                                                                                  :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/projects/:projectId/assets/disassociate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/projects/:projectId/assets/disassociate"),
    Content = new StringContent("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:projectId/assets/disassociate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId/assets/disassociate"

	payload := strings.NewReader("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\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/projects/:projectId/assets/disassociate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "assetIds": [],
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects/:projectId/assets/disassociate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:projectId/assets/disassociate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/assets/disassociate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/projects/:projectId/assets/disassociate")
  .header("content-type", "application/json")
  .body("{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/projects/:projectId/assets/disassociate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/disassociate',
  headers: {'content-type': 'application/json'},
  data: {assetIds: [], clientToken: ''}
};

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

const url = '{{baseUrl}}/projects/:projectId/assets/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetIds":[],"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects/:projectId/assets/disassociate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assetIds": [],\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId/assets/disassociate")
  .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/projects/:projectId/assets/disassociate',
  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({assetIds: [], clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/disassociate',
  headers: {'content-type': 'application/json'},
  body: {assetIds: [], clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/projects/:projectId/assets/disassociate');

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

req.type('json');
req.send({
  assetIds: [],
  clientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects/:projectId/assets/disassociate',
  headers: {'content-type': 'application/json'},
  data: {assetIds: [], clientToken: ''}
};

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

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

const url = '{{baseUrl}}/projects/:projectId/assets/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetIds":[],"clientToken":""}'
};

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 = @{ @"assetIds": @[  ],
                              @"clientToken": @"" };

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

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

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

 "{{baseUrl}}/projects/:projectId/assets/disassociate",
  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([
    'assetIds' => [
        
    ],
    'clientToken' => ''
  ]),
  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}}/projects/:projectId/assets/disassociate', [
  'body' => '{
  "assetIds": [],
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId/assets/disassociate');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'assetIds' => [
    
  ],
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/projects/:projectId/assets/disassociate');
$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}}/projects/:projectId/assets/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetIds": [],
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId/assets/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetIds": [],
  "clientToken": ""
}'

import http.client

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

payload = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/projects/:projectId/assets/disassociate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/projects/:projectId/assets/disassociate"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId/assets/disassociate"

payload <- "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\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}}/projects/:projectId/assets/disassociate")

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  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/projects/:projectId/assets/disassociate') do |req|
  req.body = "{\n  \"assetIds\": [],\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "assetIds": (),
        "clientToken": ""
    });

    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 '{
  "assetIds": [],
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/projects/:projectId/assets/disassociate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assetIds": [],\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/projects/:projectId/assets/disassociate

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:projectId/assets/disassociate")! 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}}/properties/batch/aggregates");

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/properties/batch/aggregates" {:content-type :json
                                                                        :form-params {:entries [{:entryId ""
                                                                                                 :assetId ""
                                                                                                 :propertyId ""
                                                                                                 :propertyAlias ""
                                                                                                 :aggregateTypes ""
                                                                                                 :resolution ""
                                                                                                 :startDate ""
                                                                                                 :endDate ""
                                                                                                 :qualities ""
                                                                                                 :timeOrdering ""}]
                                                                                      :nextToken ""
                                                                                      :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/properties/batch/aggregates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/aggregates"),
    Content = new StringContent("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/aggregates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/properties/batch/aggregates"

	payload := strings.NewReader("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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/properties/batch/aggregates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 309

{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/properties/batch/aggregates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/batch/aggregates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/properties/batch/aggregates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/properties/batch/aggregates")
  .header("content-type", "application/json")
  .body("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      aggregateTypes: '',
      resolution: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 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}}/properties/batch/aggregates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/aggregates',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        aggregateTypes: '',
        resolution: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/properties/batch/aggregates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","aggregateTypes":"","resolution":"","startDate":"","endDate":"","qualities":"","timeOrdering":""}],"nextToken":"","maxResults":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}}/properties/batch/aggregates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "aggregateTypes": "",\n      "resolution": "",\n      "startDate": "",\n      "endDate": "",\n      "qualities": "",\n      "timeOrdering": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/properties/batch/aggregates")
  .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/properties/batch/aggregates',
  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({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      aggregateTypes: '',
      resolution: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/aggregates',
  headers: {'content-type': 'application/json'},
  body: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        aggregateTypes: '',
        resolution: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 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}}/properties/batch/aggregates');

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

req.type('json');
req.send({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      aggregateTypes: '',
      resolution: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 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}}/properties/batch/aggregates',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        aggregateTypes: '',
        resolution: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 0
  }
};

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

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

const url = '{{baseUrl}}/properties/batch/aggregates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","aggregateTypes":"","resolution":"","startDate":"","endDate":"","qualities":"","timeOrdering":""}],"nextToken":"","maxResults":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 = @{ @"entries": @[ @{ @"entryId": @"", @"assetId": @"", @"propertyId": @"", @"propertyAlias": @"", @"aggregateTypes": @"", @"resolution": @"", @"startDate": @"", @"endDate": @"", @"qualities": @"", @"timeOrdering": @"" } ],
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/properties/batch/aggregates"]
                                                       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}}/properties/batch/aggregates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/properties/batch/aggregates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'entries' => [
        [
                'entryId' => '',
                'assetId' => '',
                'propertyId' => '',
                'propertyAlias' => '',
                'aggregateTypes' => '',
                'resolution' => '',
                'startDate' => '',
                'endDate' => '',
                'qualities' => '',
                'timeOrdering' => ''
        ]
    ],
    'nextToken' => '',
    'maxResults' => 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}}/properties/batch/aggregates', [
  'body' => '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/properties/batch/aggregates');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'aggregateTypes' => '',
        'resolution' => '',
        'startDate' => '',
        'endDate' => '',
        'qualities' => '',
        'timeOrdering' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'aggregateTypes' => '',
        'resolution' => '',
        'startDate' => '',
        'endDate' => '',
        'qualities' => '',
        'timeOrdering' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/properties/batch/aggregates');
$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}}/properties/batch/aggregates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/batch/aggregates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/properties/batch/aggregates"

payload = {
    "entries": [
        {
            "entryId": "",
            "assetId": "",
            "propertyId": "",
            "propertyAlias": "",
            "aggregateTypes": "",
            "resolution": "",
            "startDate": "",
            "endDate": "",
            "qualities": "",
            "timeOrdering": ""
        }
    ],
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/batch/aggregates"

payload <- "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/aggregates")

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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/properties/batch/aggregates') do |req|
  req.body = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"aggregateTypes\": \"\",\n      \"resolution\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "entries": (
            json!({
                "entryId": "",
                "assetId": "",
                "propertyId": "",
                "propertyAlias": "",
                "aggregateTypes": "",
                "resolution": "",
                "startDate": "",
                "endDate": "",
                "qualities": "",
                "timeOrdering": ""
            })
        ),
        "nextToken": "",
        "maxResults": 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 '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/properties/batch/aggregates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "aggregateTypes": "",\n      "resolution": "",\n      "startDate": "",\n      "endDate": "",\n      "qualities": "",\n      "timeOrdering": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/properties/batch/aggregates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "entries": [
    [
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "aggregateTypes": "",
      "resolution": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    ]
  ],
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/properties/batch/latest" {:content-type :json
                                                                    :form-params {:entries [{:entryId ""
                                                                                             :assetId ""
                                                                                             :propertyId ""
                                                                                             :propertyAlias ""}]
                                                                                  :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/properties/batch/latest"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/properties/batch/latest"),
    Content = new StringContent("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties/batch/latest");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/properties/batch/latest"

	payload := strings.NewReader("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\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/properties/batch/latest HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    }
  ],
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/properties/batch/latest")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/batch/latest"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/properties/batch/latest")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/properties/batch/latest")
  .header("content-type", "application/json")
  .body("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: ''
    }
  ],
  nextToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/latest',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [{entryId: '', assetId: '', propertyId: '', propertyAlias: ''}],
    nextToken: ''
  }
};

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

const url = '{{baseUrl}}/properties/batch/latest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":""}],"nextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/properties/batch/latest',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": ""\n    }\n  ],\n  "nextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/properties/batch/latest")
  .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/properties/batch/latest',
  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({
  entries: [{entryId: '', assetId: '', propertyId: '', propertyAlias: ''}],
  nextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/latest',
  headers: {'content-type': 'application/json'},
  body: {
    entries: [{entryId: '', assetId: '', propertyId: '', propertyAlias: ''}],
    nextToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/properties/batch/latest');

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

req.type('json');
req.send({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: ''
    }
  ],
  nextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/latest',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [{entryId: '', assetId: '', propertyId: '', propertyAlias: ''}],
    nextToken: ''
  }
};

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

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

const url = '{{baseUrl}}/properties/batch/latest';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":""}],"nextToken":""}'
};

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 = @{ @"entries": @[ @{ @"entryId": @"", @"assetId": @"", @"propertyId": @"", @"propertyAlias": @"" } ],
                              @"nextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/properties/batch/latest"]
                                                       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}}/properties/batch/latest" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}" in

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

 "{{baseUrl}}/properties/batch/latest",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'entries' => [
        [
                'entryId' => '',
                'assetId' => '',
                'propertyId' => '',
                'propertyAlias' => ''
        ]
    ],
    'nextToken' => ''
  ]),
  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}}/properties/batch/latest', [
  'body' => '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    }
  ],
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/properties/batch/latest');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => ''
    ]
  ],
  'nextToken' => ''
]));

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

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

append(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => ''
    ]
  ],
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/properties/batch/latest');
$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}}/properties/batch/latest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    }
  ],
  "nextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/batch/latest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    }
  ],
  "nextToken": ""
}'

import http.client

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

payload = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/properties/batch/latest"

payload = {
    "entries": [
        {
            "entryId": "",
            "assetId": "",
            "propertyId": "",
            "propertyAlias": ""
        }
    ],
    "nextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/batch/latest"

payload <- "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\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}}/properties/batch/latest")

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/properties/batch/latest') do |req|
  req.body = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\"\n    }\n  ],\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "entries": (
            json!({
                "entryId": "",
                "assetId": "",
                "propertyId": "",
                "propertyAlias": ""
            })
        ),
        "nextToken": ""
    });

    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 '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    }
  ],
  "nextToken": ""
}' |  \
  http POST {{baseUrl}}/properties/batch/latest \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": ""\n    }\n  ],\n  "nextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/properties/batch/latest

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "entries": [
    [
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": ""
    ]
  ],
  "nextToken": ""
] as [String : Any]

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

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

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/properties/batch/history" {:content-type :json
                                                                     :form-params {:entries [{:entryId ""
                                                                                              :assetId ""
                                                                                              :propertyId ""
                                                                                              :propertyAlias ""
                                                                                              :startDate ""
                                                                                              :endDate ""
                                                                                              :qualities ""
                                                                                              :timeOrdering ""}]
                                                                                   :nextToken ""
                                                                                   :maxResults 0}})

require "http/client"

url = "{{baseUrl}}/properties/batch/history"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/history"),
    Content = new StringContent("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/history");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/properties/batch/history"

	payload := strings.NewReader("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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/properties/batch/history HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 257

{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/properties/batch/history")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/batch/history"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/properties/batch/history")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/properties/batch/history")
  .header("content-type", "application/json")
  .body("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
  .asString();

const data = JSON.stringify({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 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}}/properties/batch/history');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/history',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 0
  }
};

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

const url = '{{baseUrl}}/properties/batch/history';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","startDate":"","endDate":"","qualities":"","timeOrdering":""}],"nextToken":"","maxResults":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}}/properties/batch/history',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "startDate": "",\n      "endDate": "",\n      "qualities": "",\n      "timeOrdering": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/properties/batch/history")
  .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/properties/batch/history',
  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({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties/batch/history',
  headers: {'content-type': 'application/json'},
  body: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 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}}/properties/batch/history');

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

req.type('json');
req.send({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      startDate: '',
      endDate: '',
      qualities: '',
      timeOrdering: ''
    }
  ],
  nextToken: '',
  maxResults: 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}}/properties/batch/history',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        startDate: '',
        endDate: '',
        qualities: '',
        timeOrdering: ''
      }
    ],
    nextToken: '',
    maxResults: 0
  }
};

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

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

const url = '{{baseUrl}}/properties/batch/history';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","startDate":"","endDate":"","qualities":"","timeOrdering":""}],"nextToken":"","maxResults":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 = @{ @"entries": @[ @{ @"entryId": @"", @"assetId": @"", @"propertyId": @"", @"propertyAlias": @"", @"startDate": @"", @"endDate": @"", @"qualities": @"", @"timeOrdering": @"" } ],
                              @"nextToken": @"",
                              @"maxResults": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/properties/batch/history"]
                                                       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}}/properties/batch/history" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}" in

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

 "{{baseUrl}}/properties/batch/history",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'entries' => [
        [
                'entryId' => '',
                'assetId' => '',
                'propertyId' => '',
                'propertyAlias' => '',
                'startDate' => '',
                'endDate' => '',
                'qualities' => '',
                'timeOrdering' => ''
        ]
    ],
    'nextToken' => '',
    'maxResults' => 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}}/properties/batch/history', [
  'body' => '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/properties/batch/history');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'startDate' => '',
        'endDate' => '',
        'qualities' => '',
        'timeOrdering' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0
]));

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

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

append(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'startDate' => '',
        'endDate' => '',
        'qualities' => '',
        'timeOrdering' => ''
    ]
  ],
  'nextToken' => '',
  'maxResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/properties/batch/history');
$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}}/properties/batch/history' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/batch/history' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}'

import http.client

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

payload = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/properties/batch/history"

payload = {
    "entries": [
        {
            "entryId": "",
            "assetId": "",
            "propertyId": "",
            "propertyAlias": "",
            "startDate": "",
            "endDate": "",
            "qualities": "",
            "timeOrdering": ""
        }
    ],
    "nextToken": "",
    "maxResults": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/batch/history"

payload <- "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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}}/properties/batch/history")

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 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/properties/batch/history') do |req|
  req.body = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"startDate\": \"\",\n      \"endDate\": \"\",\n      \"qualities\": \"\",\n      \"timeOrdering\": \"\"\n    }\n  ],\n  \"nextToken\": \"\",\n  \"maxResults\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "entries": (
            json!({
                "entryId": "",
                "assetId": "",
                "propertyId": "",
                "propertyAlias": "",
                "startDate": "",
                "endDate": "",
                "qualities": "",
                "timeOrdering": ""
            })
        ),
        "nextToken": "",
        "maxResults": 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 '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    }
  ],
  "nextToken": "",
  "maxResults": 0
}' |  \
  http POST {{baseUrl}}/properties/batch/history \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "startDate": "",\n      "endDate": "",\n      "qualities": "",\n      "timeOrdering": ""\n    }\n  ],\n  "nextToken": "",\n  "maxResults": 0\n}' \
  --output-document \
  - {{baseUrl}}/properties/batch/history

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "entries": [
    [
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "startDate": "",
      "endDate": "",
      "qualities": "",
      "timeOrdering": ""
    ]
  ],
  "nextToken": "",
  "maxResults": 0
] as [String : Any]

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

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

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/properties" {:content-type :json
                                                       :form-params {:entries [{:entryId ""
                                                                                :assetId ""
                                                                                :propertyId ""
                                                                                :propertyAlias ""
                                                                                :propertyValues ""}]}})

require "http/client"

url = "{{baseUrl}}/properties"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/properties"),
    Content = new StringContent("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/properties HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 154

{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/properties")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/properties")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/properties")
  .header("content-type", "application/json")
  .body("{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      propertyValues: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        propertyValues: ''
      }
    ]
  }
};

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

const url = '{{baseUrl}}/properties';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","propertyValues":""}]}'
};

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}}/properties',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "propertyValues": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/properties")
  .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/properties',
  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({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      propertyValues: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/properties',
  headers: {'content-type': 'application/json'},
  body: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        propertyValues: ''
      }
    ]
  },
  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}}/properties');

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

req.type('json');
req.send({
  entries: [
    {
      entryId: '',
      assetId: '',
      propertyId: '',
      propertyAlias: '',
      propertyValues: ''
    }
  ]
});

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}}/properties',
  headers: {'content-type': 'application/json'},
  data: {
    entries: [
      {
        entryId: '',
        assetId: '',
        propertyId: '',
        propertyAlias: '',
        propertyValues: ''
      }
    ]
  }
};

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

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

const url = '{{baseUrl}}/properties';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"entries":[{"entryId":"","assetId":"","propertyId":"","propertyAlias":"","propertyValues":""}]}'
};

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 = @{ @"entries": @[ @{ @"entryId": @"", @"assetId": @"", @"propertyId": @"", @"propertyAlias": @"", @"propertyValues": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/properties"]
                                                       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}}/properties" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/properties",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'entries' => [
        [
                'entryId' => '',
                'assetId' => '',
                'propertyId' => '',
                'propertyAlias' => '',
                'propertyValues' => ''
        ]
    ]
  ]),
  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}}/properties', [
  'body' => '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'propertyValues' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'entries' => [
    [
        'entryId' => '',
        'assetId' => '',
        'propertyId' => '',
        'propertyAlias' => '',
        'propertyValues' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/properties');
$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}}/properties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/properties"

payload = { "entries": [
        {
            "entryId": "",
            "assetId": "",
            "propertyId": "",
            "propertyAlias": "",
            "propertyValues": ""
        }
    ] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/properties")

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  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/properties') do |req|
  req.body = "{\n  \"entries\": [\n    {\n      \"entryId\": \"\",\n      \"assetId\": \"\",\n      \"propertyId\": \"\",\n      \"propertyAlias\": \"\",\n      \"propertyValues\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"entries": (
            json!({
                "entryId": "",
                "assetId": "",
                "propertyId": "",
                "propertyAlias": "",
                "propertyValues": ""
            })
        )});

    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 '{
  "entries": [
    {
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/properties \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "entries": [\n    {\n      "entryId": "",\n      "assetId": "",\n      "propertyId": "",\n      "propertyAlias": "",\n      "propertyValues": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/properties

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["entries": [
    [
      "entryId": "",
      "assetId": "",
      "propertyId": "",
      "propertyAlias": "",
      "propertyValues": ""
    ]
  ]] as [String : Any]

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

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

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  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/access-policies" {:content-type :json
                                                            :form-params {:accessPolicyIdentity {:user ""
                                                                                                 :group ""
                                                                                                 :iamUser ""
                                                                                                 :iamRole ""}
                                                                          :accessPolicyResource {:portal ""
                                                                                                 :project ""}
                                                                          :accessPolicyPermission ""
                                                                          :clientToken ""
                                                                          :tags {}}})

require "http/client"

url = "{{baseUrl}}/access-policies"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/access-policies"),
    Content = new StringContent("{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/access-policies");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/access-policies"

	payload := strings.NewReader("{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\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/access-policies HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 241

{
  "accessPolicyIdentity": {
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  },
  "accessPolicyResource": {
    "portal": "",
    "project": ""
  },
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/access-policies")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/access-policies"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/access-policies")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/access-policies")
  .header("content-type", "application/json")
  .body("{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  accessPolicyIdentity: {
    user: '',
    group: '',
    iamUser: '',
    iamRole: ''
  },
  accessPolicyResource: {
    portal: '',
    project: ''
  },
  accessPolicyPermission: '',
  clientToken: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/access-policies',
  headers: {'content-type': 'application/json'},
  data: {
    accessPolicyIdentity: {user: '', group: '', iamUser: '', iamRole: ''},
    accessPolicyResource: {portal: '', project: ''},
    accessPolicyPermission: '',
    clientToken: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/access-policies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accessPolicyIdentity":{"user":"","group":"","iamUser":"","iamRole":""},"accessPolicyResource":{"portal":"","project":""},"accessPolicyPermission":"","clientToken":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/access-policies',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accessPolicyIdentity": {\n    "user": "",\n    "group": "",\n    "iamUser": "",\n    "iamRole": ""\n  },\n  "accessPolicyResource": {\n    "portal": "",\n    "project": ""\n  },\n  "accessPolicyPermission": "",\n  "clientToken": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/access-policies")
  .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/access-policies',
  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({
  accessPolicyIdentity: {user: '', group: '', iamUser: '', iamRole: ''},
  accessPolicyResource: {portal: '', project: ''},
  accessPolicyPermission: '',
  clientToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/access-policies',
  headers: {'content-type': 'application/json'},
  body: {
    accessPolicyIdentity: {user: '', group: '', iamUser: '', iamRole: ''},
    accessPolicyResource: {portal: '', project: ''},
    accessPolicyPermission: '',
    clientToken: '',
    tags: {}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/access-policies');

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

req.type('json');
req.send({
  accessPolicyIdentity: {
    user: '',
    group: '',
    iamUser: '',
    iamRole: ''
  },
  accessPolicyResource: {
    portal: '',
    project: ''
  },
  accessPolicyPermission: '',
  clientToken: '',
  tags: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/access-policies',
  headers: {'content-type': 'application/json'},
  data: {
    accessPolicyIdentity: {user: '', group: '', iamUser: '', iamRole: ''},
    accessPolicyResource: {portal: '', project: ''},
    accessPolicyPermission: '',
    clientToken: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/access-policies';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"accessPolicyIdentity":{"user":"","group":"","iamUser":"","iamRole":""},"accessPolicyResource":{"portal":"","project":""},"accessPolicyPermission":"","clientToken":"","tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"accessPolicyIdentity": @{ @"user": @"", @"group": @"", @"iamUser": @"", @"iamRole": @"" },
                              @"accessPolicyResource": @{ @"portal": @"", @"project": @"" },
                              @"accessPolicyPermission": @"",
                              @"clientToken": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/access-policies"]
                                                       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}}/access-policies" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/access-policies",
  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([
    'accessPolicyIdentity' => [
        'user' => '',
        'group' => '',
        'iamUser' => '',
        'iamRole' => ''
    ],
    'accessPolicyResource' => [
        'portal' => '',
        'project' => ''
    ],
    'accessPolicyPermission' => '',
    'clientToken' => '',
    '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}}/access-policies', [
  'body' => '{
  "accessPolicyIdentity": {
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  },
  "accessPolicyResource": {
    "portal": "",
    "project": ""
  },
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accessPolicyIdentity' => [
    'user' => '',
    'group' => '',
    'iamUser' => '',
    'iamRole' => ''
  ],
  'accessPolicyResource' => [
    'portal' => '',
    'project' => ''
  ],
  'accessPolicyPermission' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'accessPolicyIdentity' => [
    'user' => '',
    'group' => '',
    'iamUser' => '',
    'iamRole' => ''
  ],
  'accessPolicyResource' => [
    'portal' => '',
    'project' => ''
  ],
  'accessPolicyPermission' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/access-policies');
$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}}/access-policies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accessPolicyIdentity": {
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  },
  "accessPolicyResource": {
    "portal": "",
    "project": ""
  },
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/access-policies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accessPolicyIdentity": {
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  },
  "accessPolicyResource": {
    "portal": "",
    "project": ""
  },
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/access-policies"

payload = {
    "accessPolicyIdentity": {
        "user": "",
        "group": "",
        "iamUser": "",
        "iamRole": ""
    },
    "accessPolicyResource": {
        "portal": "",
        "project": ""
    },
    "accessPolicyPermission": "",
    "clientToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/access-policies"

payload <- "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\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}}/access-policies")

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  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/access-policies') do |req|
  req.body = "{\n  \"accessPolicyIdentity\": {\n    \"user\": \"\",\n    \"group\": \"\",\n    \"iamUser\": \"\",\n    \"iamRole\": \"\"\n  },\n  \"accessPolicyResource\": {\n    \"portal\": \"\",\n    \"project\": \"\"\n  },\n  \"accessPolicyPermission\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "accessPolicyIdentity": json!({
            "user": "",
            "group": "",
            "iamUser": "",
            "iamRole": ""
        }),
        "accessPolicyResource": json!({
            "portal": "",
            "project": ""
        }),
        "accessPolicyPermission": "",
        "clientToken": "",
        "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 '{
  "accessPolicyIdentity": {
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  },
  "accessPolicyResource": {
    "portal": "",
    "project": ""
  },
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/access-policies \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "accessPolicyIdentity": {\n    "user": "",\n    "group": "",\n    "iamUser": "",\n    "iamRole": ""\n  },\n  "accessPolicyResource": {\n    "portal": "",\n    "project": ""\n  },\n  "accessPolicyPermission": "",\n  "clientToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/access-policies

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "accessPolicyIdentity": [
    "user": "",
    "group": "",
    "iamUser": "",
    "iamRole": ""
  ],
  "accessPolicyResource": [
    "portal": "",
    "project": ""
  ],
  "accessPolicyPermission": "",
  "clientToken": "",
  "tags": []
] as [String : Any]

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

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

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  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/assets" {:content-type :json
                                                   :form-params {:assetName ""
                                                                 :assetModelId ""
                                                                 :clientToken ""
                                                                 :tags {}
                                                                 :assetDescription ""}})

require "http/client"

url = "{{baseUrl}}/assets"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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}}/assets"),
    Content = new StringContent("{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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}}/assets");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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/assets HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": {},
  "assetDescription": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/assets")
  .header("content-type", "application/json")
  .body("{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  assetName: '',
  assetModelId: '',
  clientToken: '',
  tags: {},
  assetDescription: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets',
  headers: {'content-type': 'application/json'},
  data: {
    assetName: '',
    assetModelId: '',
    clientToken: '',
    tags: {},
    assetDescription: ''
  }
};

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

const url = '{{baseUrl}}/assets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetName":"","assetModelId":"","clientToken":"","tags":{},"assetDescription":""}'
};

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}}/assets',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assetName": "",\n  "assetModelId": "",\n  "clientToken": "",\n  "tags": {},\n  "assetDescription": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets")
  .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/assets',
  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({
  assetName: '',
  assetModelId: '',
  clientToken: '',
  tags: {},
  assetDescription: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets',
  headers: {'content-type': 'application/json'},
  body: {
    assetName: '',
    assetModelId: '',
    clientToken: '',
    tags: {},
    assetDescription: ''
  },
  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}}/assets');

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

req.type('json');
req.send({
  assetName: '',
  assetModelId: '',
  clientToken: '',
  tags: {},
  assetDescription: ''
});

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}}/assets',
  headers: {'content-type': 'application/json'},
  data: {
    assetName: '',
    assetModelId: '',
    clientToken: '',
    tags: {},
    assetDescription: ''
  }
};

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

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

const url = '{{baseUrl}}/assets';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetName":"","assetModelId":"","clientToken":"","tags":{},"assetDescription":""}'
};

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 = @{ @"assetName": @"",
                              @"assetModelId": @"",
                              @"clientToken": @"",
                              @"tags": @{  },
                              @"assetDescription": @"" };

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

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

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

 "{{baseUrl}}/assets",
  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([
    'assetName' => '',
    'assetModelId' => '',
    'clientToken' => '',
    'tags' => [
        
    ],
    'assetDescription' => ''
  ]),
  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}}/assets', [
  'body' => '{
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": {},
  "assetDescription": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assetName' => '',
  'assetModelId' => '',
  'clientToken' => '',
  'tags' => [
    
  ],
  'assetDescription' => ''
]));

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

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

append(json_encode([
  'assetName' => '',
  'assetModelId' => '',
  'clientToken' => '',
  'tags' => [
    
  ],
  'assetDescription' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets');
$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}}/assets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": {},
  "assetDescription": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": {},
  "assetDescription": ""
}'

import http.client

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

payload = "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/assets"

payload = {
    "assetName": "",
    "assetModelId": "",
    "clientToken": "",
    "tags": {},
    "assetDescription": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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}}/assets")

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  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\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/assets') do |req|
  req.body = "{\n  \"assetName\": \"\",\n  \"assetModelId\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {},\n  \"assetDescription\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "assetName": "",
        "assetModelId": "",
        "clientToken": "",
        "tags": json!({}),
        "assetDescription": ""
    });

    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 '{
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": {},
  "assetDescription": ""
}' |  \
  http POST {{baseUrl}}/assets \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assetName": "",\n  "assetModelId": "",\n  "clientToken": "",\n  "tags": {},\n  "assetDescription": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assetName": "",
  "assetModelId": "",
  "clientToken": "",
  "tags": [],
  "assetDescription": ""
] as [String : Any]

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

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

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  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/asset-models" {:content-type :json
                                                         :form-params {:assetModelName ""
                                                                       :assetModelDescription ""
                                                                       :assetModelProperties [{:name ""
                                                                                               :dataType ""
                                                                                               :dataTypeSpec ""
                                                                                               :unit ""
                                                                                               :type ""}]
                                                                       :assetModelHierarchies [{:name ""
                                                                                                :childAssetModelId ""}]
                                                                       :assetModelCompositeModels [{:name ""
                                                                                                    :description ""
                                                                                                    :type ""
                                                                                                    :properties ""}]
                                                                       :clientToken ""
                                                                       :tags {}}})

require "http/client"

url = "{{baseUrl}}/asset-models"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/asset-models"),
    Content = new StringContent("{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/asset-models");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/asset-models"

	payload := strings.NewReader("{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\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/asset-models HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 466

{
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    {
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    }
  ],
  "assetModelHierarchies": [
    {
      "name": "",
      "childAssetModelId": ""
    }
  ],
  "assetModelCompositeModels": [
    {
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    }
  ],
  "clientToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/asset-models")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/asset-models"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/asset-models")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/asset-models")
  .header("content-type", "application/json")
  .body("{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  assetModelName: '',
  assetModelDescription: '',
  assetModelProperties: [
    {
      name: '',
      dataType: '',
      dataTypeSpec: '',
      unit: '',
      type: ''
    }
  ],
  assetModelHierarchies: [
    {
      name: '',
      childAssetModelId: ''
    }
  ],
  assetModelCompositeModels: [
    {
      name: '',
      description: '',
      type: '',
      properties: ''
    }
  ],
  clientToken: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/asset-models',
  headers: {'content-type': 'application/json'},
  data: {
    assetModelName: '',
    assetModelDescription: '',
    assetModelProperties: [{name: '', dataType: '', dataTypeSpec: '', unit: '', type: ''}],
    assetModelHierarchies: [{name: '', childAssetModelId: ''}],
    assetModelCompositeModels: [{name: '', description: '', type: '', properties: ''}],
    clientToken: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/asset-models';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetModelName":"","assetModelDescription":"","assetModelProperties":[{"name":"","dataType":"","dataTypeSpec":"","unit":"","type":""}],"assetModelHierarchies":[{"name":"","childAssetModelId":""}],"assetModelCompositeModels":[{"name":"","description":"","type":"","properties":""}],"clientToken":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/asset-models',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "assetModelName": "",\n  "assetModelDescription": "",\n  "assetModelProperties": [\n    {\n      "name": "",\n      "dataType": "",\n      "dataTypeSpec": "",\n      "unit": "",\n      "type": ""\n    }\n  ],\n  "assetModelHierarchies": [\n    {\n      "name": "",\n      "childAssetModelId": ""\n    }\n  ],\n  "assetModelCompositeModels": [\n    {\n      "name": "",\n      "description": "",\n      "type": "",\n      "properties": ""\n    }\n  ],\n  "clientToken": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/asset-models")
  .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/asset-models',
  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({
  assetModelName: '',
  assetModelDescription: '',
  assetModelProperties: [{name: '', dataType: '', dataTypeSpec: '', unit: '', type: ''}],
  assetModelHierarchies: [{name: '', childAssetModelId: ''}],
  assetModelCompositeModels: [{name: '', description: '', type: '', properties: ''}],
  clientToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/asset-models',
  headers: {'content-type': 'application/json'},
  body: {
    assetModelName: '',
    assetModelDescription: '',
    assetModelProperties: [{name: '', dataType: '', dataTypeSpec: '', unit: '', type: ''}],
    assetModelHierarchies: [{name: '', childAssetModelId: ''}],
    assetModelCompositeModels: [{name: '', description: '', type: '', properties: ''}],
    clientToken: '',
    tags: {}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/asset-models');

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

req.type('json');
req.send({
  assetModelName: '',
  assetModelDescription: '',
  assetModelProperties: [
    {
      name: '',
      dataType: '',
      dataTypeSpec: '',
      unit: '',
      type: ''
    }
  ],
  assetModelHierarchies: [
    {
      name: '',
      childAssetModelId: ''
    }
  ],
  assetModelCompositeModels: [
    {
      name: '',
      description: '',
      type: '',
      properties: ''
    }
  ],
  clientToken: '',
  tags: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/asset-models',
  headers: {'content-type': 'application/json'},
  data: {
    assetModelName: '',
    assetModelDescription: '',
    assetModelProperties: [{name: '', dataType: '', dataTypeSpec: '', unit: '', type: ''}],
    assetModelHierarchies: [{name: '', childAssetModelId: ''}],
    assetModelCompositeModels: [{name: '', description: '', type: '', properties: ''}],
    clientToken: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/asset-models';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"assetModelName":"","assetModelDescription":"","assetModelProperties":[{"name":"","dataType":"","dataTypeSpec":"","unit":"","type":""}],"assetModelHierarchies":[{"name":"","childAssetModelId":""}],"assetModelCompositeModels":[{"name":"","description":"","type":"","properties":""}],"clientToken":"","tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"assetModelName": @"",
                              @"assetModelDescription": @"",
                              @"assetModelProperties": @[ @{ @"name": @"", @"dataType": @"", @"dataTypeSpec": @"", @"unit": @"", @"type": @"" } ],
                              @"assetModelHierarchies": @[ @{ @"name": @"", @"childAssetModelId": @"" } ],
                              @"assetModelCompositeModels": @[ @{ @"name": @"", @"description": @"", @"type": @"", @"properties": @"" } ],
                              @"clientToken": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/asset-models"]
                                                       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}}/asset-models" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/asset-models",
  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([
    'assetModelName' => '',
    'assetModelDescription' => '',
    'assetModelProperties' => [
        [
                'name' => '',
                'dataType' => '',
                'dataTypeSpec' => '',
                'unit' => '',
                'type' => ''
        ]
    ],
    'assetModelHierarchies' => [
        [
                'name' => '',
                'childAssetModelId' => ''
        ]
    ],
    'assetModelCompositeModels' => [
        [
                'name' => '',
                'description' => '',
                'type' => '',
                'properties' => ''
        ]
    ],
    'clientToken' => '',
    '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}}/asset-models', [
  'body' => '{
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    {
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    }
  ],
  "assetModelHierarchies": [
    {
      "name": "",
      "childAssetModelId": ""
    }
  ],
  "assetModelCompositeModels": [
    {
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    }
  ],
  "clientToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'assetModelName' => '',
  'assetModelDescription' => '',
  'assetModelProperties' => [
    [
        'name' => '',
        'dataType' => '',
        'dataTypeSpec' => '',
        'unit' => '',
        'type' => ''
    ]
  ],
  'assetModelHierarchies' => [
    [
        'name' => '',
        'childAssetModelId' => ''
    ]
  ],
  'assetModelCompositeModels' => [
    [
        'name' => '',
        'description' => '',
        'type' => '',
        'properties' => ''
    ]
  ],
  'clientToken' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'assetModelName' => '',
  'assetModelDescription' => '',
  'assetModelProperties' => [
    [
        'name' => '',
        'dataType' => '',
        'dataTypeSpec' => '',
        'unit' => '',
        'type' => ''
    ]
  ],
  'assetModelHierarchies' => [
    [
        'name' => '',
        'childAssetModelId' => ''
    ]
  ],
  'assetModelCompositeModels' => [
    [
        'name' => '',
        'description' => '',
        'type' => '',
        'properties' => ''
    ]
  ],
  'clientToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/asset-models');
$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}}/asset-models' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    {
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    }
  ],
  "assetModelHierarchies": [
    {
      "name": "",
      "childAssetModelId": ""
    }
  ],
  "assetModelCompositeModels": [
    {
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    }
  ],
  "clientToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/asset-models' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    {
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    }
  ],
  "assetModelHierarchies": [
    {
      "name": "",
      "childAssetModelId": ""
    }
  ],
  "assetModelCompositeModels": [
    {
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    }
  ],
  "clientToken": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/asset-models"

payload = {
    "assetModelName": "",
    "assetModelDescription": "",
    "assetModelProperties": [
        {
            "name": "",
            "dataType": "",
            "dataTypeSpec": "",
            "unit": "",
            "type": ""
        }
    ],
    "assetModelHierarchies": [
        {
            "name": "",
            "childAssetModelId": ""
        }
    ],
    "assetModelCompositeModels": [
        {
            "name": "",
            "description": "",
            "type": "",
            "properties": ""
        }
    ],
    "clientToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/asset-models"

payload <- "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\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}}/asset-models")

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  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/asset-models') do |req|
  req.body = "{\n  \"assetModelName\": \"\",\n  \"assetModelDescription\": \"\",\n  \"assetModelProperties\": [\n    {\n      \"name\": \"\",\n      \"dataType\": \"\",\n      \"dataTypeSpec\": \"\",\n      \"unit\": \"\",\n      \"type\": \"\"\n    }\n  ],\n  \"assetModelHierarchies\": [\n    {\n      \"name\": \"\",\n      \"childAssetModelId\": \"\"\n    }\n  ],\n  \"assetModelCompositeModels\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"type\": \"\",\n      \"properties\": \"\"\n    }\n  ],\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "assetModelName": "",
        "assetModelDescription": "",
        "assetModelProperties": (
            json!({
                "name": "",
                "dataType": "",
                "dataTypeSpec": "",
                "unit": "",
                "type": ""
            })
        ),
        "assetModelHierarchies": (
            json!({
                "name": "",
                "childAssetModelId": ""
            })
        ),
        "assetModelCompositeModels": (
            json!({
                "name": "",
                "description": "",
                "type": "",
                "properties": ""
            })
        ),
        "clientToken": "",
        "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 '{
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    {
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    }
  ],
  "assetModelHierarchies": [
    {
      "name": "",
      "childAssetModelId": ""
    }
  ],
  "assetModelCompositeModels": [
    {
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    }
  ],
  "clientToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/asset-models \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "assetModelName": "",\n  "assetModelDescription": "",\n  "assetModelProperties": [\n    {\n      "name": "",\n      "dataType": "",\n      "dataTypeSpec": "",\n      "unit": "",\n      "type": ""\n    }\n  ],\n  "assetModelHierarchies": [\n    {\n      "name": "",\n      "childAssetModelId": ""\n    }\n  ],\n  "assetModelCompositeModels": [\n    {\n      "name": "",\n      "description": "",\n      "type": "",\n      "properties": ""\n    }\n  ],\n  "clientToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/asset-models

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "assetModelName": "",
  "assetModelDescription": "",
  "assetModelProperties": [
    [
      "name": "",
      "dataType": "",
      "dataTypeSpec": "",
      "unit": "",
      "type": ""
    ]
  ],
  "assetModelHierarchies": [
    [
      "name": "",
      "childAssetModelId": ""
    ]
  ],
  "assetModelCompositeModels": [
    [
      "name": "",
      "description": "",
      "type": "",
      "properties": ""
    ]
  ],
  "clientToken": "",
  "tags": []
] as [String : Any]

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

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

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  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/jobs" {:content-type :json
                                                 :form-params {:jobName ""
                                                               :jobRoleArn ""
                                                               :files [{:bucket ""
                                                                        :key ""
                                                                        :versionId ""}]
                                                               :errorReportLocation {:bucket ""
                                                                                     :prefix ""}
                                                               :jobConfiguration {:fileFormat ""}}})

require "http/client"

url = "{{baseUrl}}/jobs"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\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}}/jobs"),
    Content = new StringContent("{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/jobs");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\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/jobs HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 245

{
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    {
      "bucket": "",
      "key": "",
      "versionId": ""
    }
  ],
  "errorReportLocation": {
    "bucket": "",
    "prefix": ""
  },
  "jobConfiguration": {
    "fileFormat": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/jobs")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\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  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/jobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/jobs")
  .header("content-type", "application/json")
  .body("{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  jobName: '',
  jobRoleArn: '',
  files: [
    {
      bucket: '',
      key: '',
      versionId: ''
    }
  ],
  errorReportLocation: {
    bucket: '',
    prefix: ''
  },
  jobConfiguration: {
    fileFormat: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/jobs',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobRoleArn: '',
    files: [{bucket: '', key: '', versionId: ''}],
    errorReportLocation: {bucket: '', prefix: ''},
    jobConfiguration: {fileFormat: ''}
  }
};

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

const url = '{{baseUrl}}/jobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobRoleArn":"","files":[{"bucket":"","key":"","versionId":""}],"errorReportLocation":{"bucket":"","prefix":""},"jobConfiguration":{"fileFormat":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/jobs',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "jobName": "",\n  "jobRoleArn": "",\n  "files": [\n    {\n      "bucket": "",\n      "key": "",\n      "versionId": ""\n    }\n  ],\n  "errorReportLocation": {\n    "bucket": "",\n    "prefix": ""\n  },\n  "jobConfiguration": {\n    "fileFormat": ""\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  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/jobs")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jobs',
  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({
  jobName: '',
  jobRoleArn: '',
  files: [{bucket: '', key: '', versionId: ''}],
  errorReportLocation: {bucket: '', prefix: ''},
  jobConfiguration: {fileFormat: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/jobs',
  headers: {'content-type': 'application/json'},
  body: {
    jobName: '',
    jobRoleArn: '',
    files: [{bucket: '', key: '', versionId: ''}],
    errorReportLocation: {bucket: '', prefix: ''},
    jobConfiguration: {fileFormat: ''}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/jobs');

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

req.type('json');
req.send({
  jobName: '',
  jobRoleArn: '',
  files: [
    {
      bucket: '',
      key: '',
      versionId: ''
    }
  ],
  errorReportLocation: {
    bucket: '',
    prefix: ''
  },
  jobConfiguration: {
    fileFormat: ''
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/jobs',
  headers: {'content-type': 'application/json'},
  data: {
    jobName: '',
    jobRoleArn: '',
    files: [{bucket: '', key: '', versionId: ''}],
    errorReportLocation: {bucket: '', prefix: ''},
    jobConfiguration: {fileFormat: ''}
  }
};

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

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

const url = '{{baseUrl}}/jobs';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"jobName":"","jobRoleArn":"","files":[{"bucket":"","key":"","versionId":""}],"errorReportLocation":{"bucket":"","prefix":""},"jobConfiguration":{"fileFormat":""}}'
};

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 = @{ @"jobName": @"",
                              @"jobRoleArn": @"",
                              @"files": @[ @{ @"bucket": @"", @"key": @"", @"versionId": @"" } ],
                              @"errorReportLocation": @{ @"bucket": @"", @"prefix": @"" },
                              @"jobConfiguration": @{ @"fileFormat": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/jobs"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/jobs" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/jobs",
  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([
    'jobName' => '',
    'jobRoleArn' => '',
    'files' => [
        [
                'bucket' => '',
                'key' => '',
                'versionId' => ''
        ]
    ],
    'errorReportLocation' => [
        'bucket' => '',
        'prefix' => ''
    ],
    'jobConfiguration' => [
        'fileFormat' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/jobs', [
  'body' => '{
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    {
      "bucket": "",
      "key": "",
      "versionId": ""
    }
  ],
  "errorReportLocation": {
    "bucket": "",
    "prefix": ""
  },
  "jobConfiguration": {
    "fileFormat": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobName' => '',
  'jobRoleArn' => '',
  'files' => [
    [
        'bucket' => '',
        'key' => '',
        'versionId' => ''
    ]
  ],
  'errorReportLocation' => [
    'bucket' => '',
    'prefix' => ''
  ],
  'jobConfiguration' => [
    'fileFormat' => ''
  ]
]));

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

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

append(json_encode([
  'jobName' => '',
  'jobRoleArn' => '',
  'files' => [
    [
        'bucket' => '',
        'key' => '',
        'versionId' => ''
    ]
  ],
  'errorReportLocation' => [
    'bucket' => '',
    'prefix' => ''
  ],
  'jobConfiguration' => [
    'fileFormat' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/jobs');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    {
      "bucket": "",
      "key": "",
      "versionId": ""
    }
  ],
  "errorReportLocation": {
    "bucket": "",
    "prefix": ""
  },
  "jobConfiguration": {
    "fileFormat": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    {
      "bucket": "",
      "key": "",
      "versionId": ""
    }
  ],
  "errorReportLocation": {
    "bucket": "",
    "prefix": ""
  },
  "jobConfiguration": {
    "fileFormat": ""
  }
}'

import http.client

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

payload = "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/jobs"

payload = {
    "jobName": "",
    "jobRoleArn": "",
    "files": [
        {
            "bucket": "",
            "key": "",
            "versionId": ""
        }
    ],
    "errorReportLocation": {
        "bucket": "",
        "prefix": ""
    },
    "jobConfiguration": { "fileFormat": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\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}}/jobs")

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  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\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/jobs') do |req|
  req.body = "{\n  \"jobName\": \"\",\n  \"jobRoleArn\": \"\",\n  \"files\": [\n    {\n      \"bucket\": \"\",\n      \"key\": \"\",\n      \"versionId\": \"\"\n    }\n  ],\n  \"errorReportLocation\": {\n    \"bucket\": \"\",\n    \"prefix\": \"\"\n  },\n  \"jobConfiguration\": {\n    \"fileFormat\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "jobName": "",
        "jobRoleArn": "",
        "files": (
            json!({
                "bucket": "",
                "key": "",
                "versionId": ""
            })
        ),
        "errorReportLocation": json!({
            "bucket": "",
            "prefix": ""
        }),
        "jobConfiguration": json!({"fileFormat": ""})
    });

    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 '{
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    {
      "bucket": "",
      "key": "",
      "versionId": ""
    }
  ],
  "errorReportLocation": {
    "bucket": "",
    "prefix": ""
  },
  "jobConfiguration": {
    "fileFormat": ""
  }
}' |  \
  http POST {{baseUrl}}/jobs \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobName": "",\n  "jobRoleArn": "",\n  "files": [\n    {\n      "bucket": "",\n      "key": "",\n      "versionId": ""\n    }\n  ],\n  "errorReportLocation": {\n    "bucket": "",\n    "prefix": ""\n  },\n  "jobConfiguration": {\n    "fileFormat": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/jobs

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "jobName": "",
  "jobRoleArn": "",
  "files": [
    [
      "bucket": "",
      "key": "",
      "versionId": ""
    ]
  ],
  "errorReportLocation": [
    "bucket": "",
    "prefix": ""
  ],
  "jobConfiguration": ["fileFormat": ""]
] as [String : Any]

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

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

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  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/dashboards" {:content-type :json
                                                       :form-params {:projectId ""
                                                                     :dashboardName ""
                                                                     :dashboardDescription ""
                                                                     :dashboardDefinition ""
                                                                     :clientToken ""
                                                                     :tags {}}})

require "http/client"

url = "{{baseUrl}}/dashboards"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/dashboards"),
    Content = new StringContent("{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dashboards");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\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/dashboards HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/dashboards")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboards"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/dashboards")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/dashboards")
  .header("content-type", "application/json")
  .body("{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  projectId: '',
  dashboardName: '',
  dashboardDescription: '',
  dashboardDefinition: '',
  clientToken: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboards',
  headers: {'content-type': 'application/json'},
  data: {
    projectId: '',
    dashboardName: '',
    dashboardDescription: '',
    dashboardDefinition: '',
    clientToken: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/dashboards';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"projectId":"","dashboardName":"","dashboardDescription":"","dashboardDefinition":"","clientToken":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/dashboards',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "projectId": "",\n  "dashboardName": "",\n  "dashboardDescription": "",\n  "dashboardDefinition": "",\n  "clientToken": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/dashboards")
  .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/dashboards',
  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({
  projectId: '',
  dashboardName: '',
  dashboardDescription: '',
  dashboardDefinition: '',
  clientToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboards',
  headers: {'content-type': 'application/json'},
  body: {
    projectId: '',
    dashboardName: '',
    dashboardDescription: '',
    dashboardDefinition: '',
    clientToken: '',
    tags: {}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/dashboards');

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

req.type('json');
req.send({
  projectId: '',
  dashboardName: '',
  dashboardDescription: '',
  dashboardDefinition: '',
  clientToken: '',
  tags: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/dashboards',
  headers: {'content-type': 'application/json'},
  data: {
    projectId: '',
    dashboardName: '',
    dashboardDescription: '',
    dashboardDefinition: '',
    clientToken: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/dashboards';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"projectId":"","dashboardName":"","dashboardDescription":"","dashboardDefinition":"","clientToken":"","tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"projectId": @"",
                              @"dashboardName": @"",
                              @"dashboardDescription": @"",
                              @"dashboardDefinition": @"",
                              @"clientToken": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/dashboards"]
                                                       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}}/dashboards" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/dashboards",
  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([
    'projectId' => '',
    'dashboardName' => '',
    'dashboardDescription' => '',
    'dashboardDefinition' => '',
    'clientToken' => '',
    '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}}/dashboards', [
  'body' => '{
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'projectId' => '',
  'dashboardName' => '',
  'dashboardDescription' => '',
  'dashboardDefinition' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'projectId' => '',
  'dashboardName' => '',
  'dashboardDescription' => '',
  'dashboardDefinition' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/dashboards');
$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}}/dashboards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboards' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/dashboards"

payload = {
    "projectId": "",
    "dashboardName": "",
    "dashboardDescription": "",
    "dashboardDefinition": "",
    "clientToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\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}}/dashboards")

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  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/dashboards') do |req|
  req.body = "{\n  \"projectId\": \"\",\n  \"dashboardName\": \"\",\n  \"dashboardDescription\": \"\",\n  \"dashboardDefinition\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "projectId": "",
        "dashboardName": "",
        "dashboardDescription": "",
        "dashboardDefinition": "",
        "clientToken": "",
        "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 '{
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/dashboards \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "projectId": "",\n  "dashboardName": "",\n  "dashboardDescription": "",\n  "dashboardDefinition": "",\n  "clientToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/dashboards

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "projectId": "",
  "dashboardName": "",
  "dashboardDescription": "",
  "dashboardDefinition": "",
  "clientToken": "",
  "tags": []
] as [String : Any]

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

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

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  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/20200301/gateways" {:content-type :json
                                                              :form-params {:gatewayName ""
                                                                            :gatewayPlatform {:greengrass ""
                                                                                              :greengrassV2 ""}
                                                                            :tags {}}})

require "http/client"

url = "{{baseUrl}}/20200301/gateways"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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}}/20200301/gateways"),
    Content = new StringContent("{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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}}/20200301/gateways");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/20200301/gateways"

	payload := strings.NewReader("{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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/20200301/gateways HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 110

{
  "gatewayName": "",
  "gatewayPlatform": {
    "greengrass": "",
    "greengrassV2": ""
  },
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/20200301/gateways")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/20200301/gateways"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/20200301/gateways")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/20200301/gateways")
  .header("content-type", "application/json")
  .body("{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  gatewayName: '',
  gatewayPlatform: {
    greengrass: '',
    greengrassV2: ''
  },
  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}}/20200301/gateways');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/20200301/gateways',
  headers: {'content-type': 'application/json'},
  data: {gatewayName: '', gatewayPlatform: {greengrass: '', greengrassV2: ''}, tags: {}}
};

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

const url = '{{baseUrl}}/20200301/gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"gatewayName":"","gatewayPlatform":{"greengrass":"","greengrassV2":""},"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}}/20200301/gateways',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "gatewayName": "",\n  "gatewayPlatform": {\n    "greengrass": "",\n    "greengrassV2": ""\n  },\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  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/20200301/gateways")
  .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/20200301/gateways',
  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({gatewayName: '', gatewayPlatform: {greengrass: '', greengrassV2: ''}, tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/20200301/gateways',
  headers: {'content-type': 'application/json'},
  body: {gatewayName: '', gatewayPlatform: {greengrass: '', greengrassV2: ''}, 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}}/20200301/gateways');

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

req.type('json');
req.send({
  gatewayName: '',
  gatewayPlatform: {
    greengrass: '',
    greengrassV2: ''
  },
  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}}/20200301/gateways',
  headers: {'content-type': 'application/json'},
  data: {gatewayName: '', gatewayPlatform: {greengrass: '', greengrassV2: ''}, tags: {}}
};

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

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

const url = '{{baseUrl}}/20200301/gateways';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"gatewayName":"","gatewayPlatform":{"greengrass":"","greengrassV2":""},"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 = @{ @"gatewayName": @"",
                              @"gatewayPlatform": @{ @"greengrass": @"", @"greengrassV2": @"" },
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/20200301/gateways"]
                                                       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}}/20200301/gateways" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/20200301/gateways",
  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([
    'gatewayName' => '',
    'gatewayPlatform' => [
        'greengrass' => '',
        'greengrassV2' => ''
    ],
    '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}}/20200301/gateways', [
  'body' => '{
  "gatewayName": "",
  "gatewayPlatform": {
    "greengrass": "",
    "greengrassV2": ""
  },
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'gatewayName' => '',
  'gatewayPlatform' => [
    'greengrass' => '',
    'greengrassV2' => ''
  ],
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'gatewayName' => '',
  'gatewayPlatform' => [
    'greengrass' => '',
    'greengrassV2' => ''
  ],
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/20200301/gateways');
$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}}/20200301/gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "gatewayName": "",
  "gatewayPlatform": {
    "greengrass": "",
    "greengrassV2": ""
  },
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/20200301/gateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "gatewayName": "",
  "gatewayPlatform": {
    "greengrass": "",
    "greengrassV2": ""
  },
  "tags": {}
}'

import http.client

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

payload = "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/20200301/gateways"

payload = {
    "gatewayName": "",
    "gatewayPlatform": {
        "greengrass": "",
        "greengrassV2": ""
    },
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/20200301/gateways"

payload <- "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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}}/20200301/gateways")

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  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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/20200301/gateways') do |req|
  req.body = "{\n  \"gatewayName\": \"\",\n  \"gatewayPlatform\": {\n    \"greengrass\": \"\",\n    \"greengrassV2\": \"\"\n  },\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}}/20200301/gateways";

    let payload = json!({
        "gatewayName": "",
        "gatewayPlatform": json!({
            "greengrass": "",
            "greengrassV2": ""
        }),
        "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 '{
  "gatewayName": "",
  "gatewayPlatform": {
    "greengrass": "",
    "greengrassV2": ""
  },
  "tags": {}
}' |  \
  http POST {{baseUrl}}/20200301/gateways \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "gatewayName": "",\n  "gatewayPlatform": {\n    "greengrass": "",\n    "greengrassV2": ""\n  },\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/20200301/gateways

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "gatewayName": "",
  "gatewayPlatform": [
    "greengrass": "",
    "greengrassV2": ""
  ],
  "tags": []
] as [String : Any]

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

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

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  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/portals" {:content-type :json
                                                    :form-params {:portalName ""
                                                                  :portalDescription ""
                                                                  :portalContactEmail ""
                                                                  :clientToken ""
                                                                  :portalLogoImageFile {:data ""
                                                                                        :type ""}
                                                                  :roleArn ""
                                                                  :tags {}
                                                                  :portalAuthMode ""
                                                                  :notificationSenderEmail ""
                                                                  :alarms {:alarmRoleArn ""
                                                                           :notificationLambdaArn ""}}})

require "http/client"

url = "{{baseUrl}}/portals"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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}}/portals"),
    Content = new StringContent("{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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}}/portals");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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/portals HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 324

{
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": {
    "data": "",
    "type": ""
  },
  "roleArn": "",
  "tags": {},
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": {
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/portals")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portals"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/portals")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/portals")
  .header("content-type", "application/json")
  .body("{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  portalName: '',
  portalDescription: '',
  portalContactEmail: '',
  clientToken: '',
  portalLogoImageFile: {
    data: '',
    type: ''
  },
  roleArn: '',
  tags: {},
  portalAuthMode: '',
  notificationSenderEmail: '',
  alarms: {
    alarmRoleArn: '',
    notificationLambdaArn: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portals',
  headers: {'content-type': 'application/json'},
  data: {
    portalName: '',
    portalDescription: '',
    portalContactEmail: '',
    clientToken: '',
    portalLogoImageFile: {data: '', type: ''},
    roleArn: '',
    tags: {},
    portalAuthMode: '',
    notificationSenderEmail: '',
    alarms: {alarmRoleArn: '', notificationLambdaArn: ''}
  }
};

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

const url = '{{baseUrl}}/portals';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portalName":"","portalDescription":"","portalContactEmail":"","clientToken":"","portalLogoImageFile":{"data":"","type":""},"roleArn":"","tags":{},"portalAuthMode":"","notificationSenderEmail":"","alarms":{"alarmRoleArn":"","notificationLambdaArn":""}}'
};

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}}/portals',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portalName": "",\n  "portalDescription": "",\n  "portalContactEmail": "",\n  "clientToken": "",\n  "portalLogoImageFile": {\n    "data": "",\n    "type": ""\n  },\n  "roleArn": "",\n  "tags": {},\n  "portalAuthMode": "",\n  "notificationSenderEmail": "",\n  "alarms": {\n    "alarmRoleArn": "",\n    "notificationLambdaArn": ""\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  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/portals")
  .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/portals',
  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({
  portalName: '',
  portalDescription: '',
  portalContactEmail: '',
  clientToken: '',
  portalLogoImageFile: {data: '', type: ''},
  roleArn: '',
  tags: {},
  portalAuthMode: '',
  notificationSenderEmail: '',
  alarms: {alarmRoleArn: '', notificationLambdaArn: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/portals',
  headers: {'content-type': 'application/json'},
  body: {
    portalName: '',
    portalDescription: '',
    portalContactEmail: '',
    clientToken: '',
    portalLogoImageFile: {data: '', type: ''},
    roleArn: '',
    tags: {},
    portalAuthMode: '',
    notificationSenderEmail: '',
    alarms: {alarmRoleArn: '', notificationLambdaArn: ''}
  },
  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}}/portals');

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

req.type('json');
req.send({
  portalName: '',
  portalDescription: '',
  portalContactEmail: '',
  clientToken: '',
  portalLogoImageFile: {
    data: '',
    type: ''
  },
  roleArn: '',
  tags: {},
  portalAuthMode: '',
  notificationSenderEmail: '',
  alarms: {
    alarmRoleArn: '',
    notificationLambdaArn: ''
  }
});

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}}/portals',
  headers: {'content-type': 'application/json'},
  data: {
    portalName: '',
    portalDescription: '',
    portalContactEmail: '',
    clientToken: '',
    portalLogoImageFile: {data: '', type: ''},
    roleArn: '',
    tags: {},
    portalAuthMode: '',
    notificationSenderEmail: '',
    alarms: {alarmRoleArn: '', notificationLambdaArn: ''}
  }
};

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

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

const url = '{{baseUrl}}/portals';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portalName":"","portalDescription":"","portalContactEmail":"","clientToken":"","portalLogoImageFile":{"data":"","type":""},"roleArn":"","tags":{},"portalAuthMode":"","notificationSenderEmail":"","alarms":{"alarmRoleArn":"","notificationLambdaArn":""}}'
};

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 = @{ @"portalName": @"",
                              @"portalDescription": @"",
                              @"portalContactEmail": @"",
                              @"clientToken": @"",
                              @"portalLogoImageFile": @{ @"data": @"", @"type": @"" },
                              @"roleArn": @"",
                              @"tags": @{  },
                              @"portalAuthMode": @"",
                              @"notificationSenderEmail": @"",
                              @"alarms": @{ @"alarmRoleArn": @"", @"notificationLambdaArn": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/portals"]
                                                       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}}/portals" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/portals",
  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([
    'portalName' => '',
    'portalDescription' => '',
    'portalContactEmail' => '',
    'clientToken' => '',
    'portalLogoImageFile' => [
        'data' => '',
        'type' => ''
    ],
    'roleArn' => '',
    'tags' => [
        
    ],
    'portalAuthMode' => '',
    'notificationSenderEmail' => '',
    'alarms' => [
        'alarmRoleArn' => '',
        'notificationLambdaArn' => ''
    ]
  ]),
  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}}/portals', [
  'body' => '{
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": {
    "data": "",
    "type": ""
  },
  "roleArn": "",
  "tags": {},
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": {
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portalName' => '',
  'portalDescription' => '',
  'portalContactEmail' => '',
  'clientToken' => '',
  'portalLogoImageFile' => [
    'data' => '',
    'type' => ''
  ],
  'roleArn' => '',
  'tags' => [
    
  ],
  'portalAuthMode' => '',
  'notificationSenderEmail' => '',
  'alarms' => [
    'alarmRoleArn' => '',
    'notificationLambdaArn' => ''
  ]
]));

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

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

append(json_encode([
  'portalName' => '',
  'portalDescription' => '',
  'portalContactEmail' => '',
  'clientToken' => '',
  'portalLogoImageFile' => [
    'data' => '',
    'type' => ''
  ],
  'roleArn' => '',
  'tags' => [
    
  ],
  'portalAuthMode' => '',
  'notificationSenderEmail' => '',
  'alarms' => [
    'alarmRoleArn' => '',
    'notificationLambdaArn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/portals');
$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}}/portals' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": {
    "data": "",
    "type": ""
  },
  "roleArn": "",
  "tags": {},
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": {
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/portals' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": {
    "data": "",
    "type": ""
  },
  "roleArn": "",
  "tags": {},
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": {
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  }
}'

import http.client

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

payload = "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/portals"

payload = {
    "portalName": "",
    "portalDescription": "",
    "portalContactEmail": "",
    "clientToken": "",
    "portalLogoImageFile": {
        "data": "",
        "type": ""
    },
    "roleArn": "",
    "tags": {},
    "portalAuthMode": "",
    "notificationSenderEmail": "",
    "alarms": {
        "alarmRoleArn": "",
        "notificationLambdaArn": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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}}/portals")

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  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\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/portals') do |req|
  req.body = "{\n  \"portalName\": \"\",\n  \"portalDescription\": \"\",\n  \"portalContactEmail\": \"\",\n  \"clientToken\": \"\",\n  \"portalLogoImageFile\": {\n    \"data\": \"\",\n    \"type\": \"\"\n  },\n  \"roleArn\": \"\",\n  \"tags\": {},\n  \"portalAuthMode\": \"\",\n  \"notificationSenderEmail\": \"\",\n  \"alarms\": {\n    \"alarmRoleArn\": \"\",\n    \"notificationLambdaArn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "portalName": "",
        "portalDescription": "",
        "portalContactEmail": "",
        "clientToken": "",
        "portalLogoImageFile": json!({
            "data": "",
            "type": ""
        }),
        "roleArn": "",
        "tags": json!({}),
        "portalAuthMode": "",
        "notificationSenderEmail": "",
        "alarms": json!({
            "alarmRoleArn": "",
            "notificationLambdaArn": ""
        })
    });

    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 '{
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": {
    "data": "",
    "type": ""
  },
  "roleArn": "",
  "tags": {},
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": {
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  }
}' |  \
  http POST {{baseUrl}}/portals \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portalName": "",\n  "portalDescription": "",\n  "portalContactEmail": "",\n  "clientToken": "",\n  "portalLogoImageFile": {\n    "data": "",\n    "type": ""\n  },\n  "roleArn": "",\n  "tags": {},\n  "portalAuthMode": "",\n  "notificationSenderEmail": "",\n  "alarms": {\n    "alarmRoleArn": "",\n    "notificationLambdaArn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/portals

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "portalName": "",
  "portalDescription": "",
  "portalContactEmail": "",
  "clientToken": "",
  "portalLogoImageFile": [
    "data": "",
    "type": ""
  ],
  "roleArn": "",
  "tags": [],
  "portalAuthMode": "",
  "notificationSenderEmail": "",
  "alarms": [
    "alarmRoleArn": "",
    "notificationLambdaArn": ""
  ]
] as [String : Any]

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

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

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  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/projects" {:content-type :json
                                                     :form-params {:portalId ""
                                                                   :projectName ""
                                                                   :projectDescription ""
                                                                   :clientToken ""
                                                                   :tags {}}})

require "http/client"

url = "{{baseUrl}}/projects"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/projects"),
    Content = new StringContent("{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\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/projects HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/projects")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/projects")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/projects")
  .header("content-type", "application/json")
  .body("{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  portalId: '',
  projectName: '',
  projectDescription: '',
  clientToken: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects',
  headers: {'content-type': 'application/json'},
  data: {
    portalId: '',
    projectName: '',
    projectDescription: '',
    clientToken: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portalId":"","projectName":"","projectDescription":"","clientToken":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/projects',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "portalId": "",\n  "projectName": "",\n  "projectDescription": "",\n  "clientToken": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/projects")
  .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/projects',
  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({
  portalId: '',
  projectName: '',
  projectDescription: '',
  clientToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects',
  headers: {'content-type': 'application/json'},
  body: {
    portalId: '',
    projectName: '',
    projectDescription: '',
    clientToken: '',
    tags: {}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/projects');

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

req.type('json');
req.send({
  portalId: '',
  projectName: '',
  projectDescription: '',
  clientToken: '',
  tags: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/projects',
  headers: {'content-type': 'application/json'},
  data: {
    portalId: '',
    projectName: '',
    projectDescription: '',
    clientToken: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/projects';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"portalId":"","projectName":"","projectDescription":"","clientToken":"","tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"portalId": @"",
                              @"projectName": @"",
                              @"projectDescription": @"",
                              @"clientToken": @"",
                              @"tags": @{  } };

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

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

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

 "{{baseUrl}}/projects",
  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([
    'portalId' => '',
    'projectName' => '',
    'projectDescription' => '',
    'clientToken' => '',
    '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}}/projects', [
  'body' => '{
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'portalId' => '',
  'projectName' => '',
  'projectDescription' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'portalId' => '',
  'projectName' => '',
  'projectDescription' => '',
  'clientToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/projects');
$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}}/projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/projects"

payload = {
    "portalId": "",
    "projectName": "",
    "projectDescription": "",
    "clientToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\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}}/projects")

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  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/projects') do |req|
  req.body = "{\n  \"portalId\": \"\",\n  \"projectName\": \"\",\n  \"projectDescription\": \"\",\n  \"clientToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "portalId": "",
        "projectName": "",
        "projectDescription": "",
        "clientToken": "",
        "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 '{
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/projects \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "portalId": "",\n  "projectName": "",\n  "projectDescription": "",\n  "clientToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/projects

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "portalId": "",
  "projectName": "",
  "projectDescription": "",
  "clientToken": "",
  "tags": []
] as [String : Any]

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/access-policies/:accessPolicyId")

require "http/client"

url = "{{baseUrl}}/access-policies/:accessPolicyId"

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

var client = new RestClient("{{baseUrl}}/access-policies/:accessPolicyId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/access-policies/:accessPolicyId"

	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/access-policies/:accessPolicyId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/access-policies/:accessPolicyId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/access-policies/:accessPolicyId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/access-policies/:accessPolicyId');

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}}/access-policies/:accessPolicyId'
};

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

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

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

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

 "{{baseUrl}}/access-policies/:accessPolicyId",
  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}}/access-policies/:accessPolicyId');

echo $response->getBody();

setUrl('{{baseUrl}}/access-policies/:accessPolicyId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/access-policies/:accessPolicyId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/access-policies/:accessPolicyId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/access-policies/:accessPolicyId")

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

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

import requests

url = "{{baseUrl}}/access-policies/:accessPolicyId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/access-policies/:accessPolicyId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/access-policies/:accessPolicyId")

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/access-policies/:accessPolicyId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/access-policies/:accessPolicyId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/access-policies/:accessPolicyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/access-policies/:accessPolicyId")! 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}}/assets/:assetId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/assets/:assetId")

require "http/client"

url = "{{baseUrl}}/assets/:assetId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/assets/:assetId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/assets/:assetId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/assets/:assetId');

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/assets/:assetId")

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

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

import requests

url = "{{baseUrl}}/assets/:assetId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

puts response.status
puts response.body

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

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

    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}}/assets/:assetId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/assets/:assetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId")! 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}}/asset-models/:assetModelId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/asset-models/:assetModelId")

require "http/client"

url = "{{baseUrl}}/asset-models/:assetModelId"

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

var client = new RestClient("{{baseUrl}}/asset-models/:assetModelId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/asset-models/:assetModelId"

	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/asset-models/:assetModelId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/asset-models/:assetModelId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/asset-models/:assetModelId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/asset-models/:assetModelId');

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}}/asset-models/:assetModelId'
};

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

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

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

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

 "{{baseUrl}}/asset-models/:assetModelId",
  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}}/asset-models/:assetModelId');

echo $response->getBody();

setUrl('{{baseUrl}}/asset-models/:assetModelId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/asset-models/:assetModelId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/asset-models/:assetModelId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/asset-models/:assetModelId")

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

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

import requests

url = "{{baseUrl}}/asset-models/:assetModelId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/asset-models/:assetModelId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/asset-models/:assetModelId")

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/asset-models/:assetModelId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/asset-models/:assetModelId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/asset-models/:assetModelId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/asset-models/:assetModelId")! 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}}/dashboards/:dashboardId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/dashboards/:dashboardId")

require "http/client"

url = "{{baseUrl}}/dashboards/:dashboardId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/dashboards/:dashboardId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/dashboards/:dashboardId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/dashboards/:dashboardId');

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}}/dashboards/:dashboardId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboards/:dashboardId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboards/:dashboardId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/dashboards/:dashboardId")

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

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

import requests

url = "{{baseUrl}}/dashboards/:dashboardId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dashboards/:dashboardId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboards/:dashboardId")

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/dashboards/:dashboardId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/dashboards/:dashboardId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/dashboards/:dashboardId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboards/:dashboardId")! 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}}/20200301/gateways/:gatewayId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/20200301/gateways/:gatewayId")

require "http/client"

url = "{{baseUrl}}/20200301/gateways/:gatewayId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/20200301/gateways/:gatewayId"

	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/20200301/gateways/:gatewayId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/20200301/gateways/:gatewayId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/20200301/gateways/:gatewayId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/20200301/gateways/:gatewayId');

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}}/20200301/gateways/:gatewayId'
};

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

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

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

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

 "{{baseUrl}}/20200301/gateways/:gatewayId",
  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}}/20200301/gateways/:gatewayId');

echo $response->getBody();

setUrl('{{baseUrl}}/20200301/gateways/:gatewayId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/20200301/gateways/:gatewayId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/20200301/gateways/:gatewayId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/20200301/gateways/:gatewayId")

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

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

import requests

url = "{{baseUrl}}/20200301/gateways/:gatewayId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/20200301/gateways/:gatewayId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/20200301/gateways/:gatewayId")

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/20200301/gateways/:gatewayId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/20200301/gateways/:gatewayId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/20200301/gateways/:gatewayId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/20200301/gateways/:gatewayId")! 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}}/portals/:portalId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/portals/:portalId")

require "http/client"

url = "{{baseUrl}}/portals/:portalId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/portals/:portalId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/portals/:portalId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/portals/:portalId');

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}}/portals/:portalId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/portals/:portalId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/portals/:portalId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/portals/:portalId")

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

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

import requests

url = "{{baseUrl}}/portals/:portalId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portals/:portalId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portals/:portalId")

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/portals/:portalId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/portals/:portalId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/portals/:portalId

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/projects/:projectId")

require "http/client"

url = "{{baseUrl}}/projects/:projectId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/projects/:projectId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/projects/:projectId'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/projects/:projectId');

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}}/projects/:projectId'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/projects/:projectId")

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

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

import requests

url = "{{baseUrl}}/projects/:projectId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId")

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/projects/:projectId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/projects/:projectId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/projects/:projectId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:projectId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timeseries/delete/");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/timeseries/delete/" {:content-type :json
                                                               :form-params {:clientToken ""}})

require "http/client"

url = "{{baseUrl}}/timeseries/delete/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/timeseries/delete/"),
    Content = new StringContent("{\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/timeseries/delete/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/timeseries/delete/"

	payload := strings.NewReader("{\n  \"clientToken\": \"\"\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/timeseries/delete/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "clientToken": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeseries/delete/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/timeseries/delete/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/timeseries/delete/")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/delete/',
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

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

const url = '{{baseUrl}}/timeseries/delete/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/timeseries/delete/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/timeseries/delete/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/delete/',
  headers: {'content-type': 'application/json'},
  body: {clientToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/timeseries/delete/');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/delete/',
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

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

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

const url = '{{baseUrl}}/timeseries/delete/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/timeseries/delete/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/timeseries/delete/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\"\n}" in

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

 "{{baseUrl}}/timeseries/delete/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => ''
  ]),
  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}}/timeseries/delete/', [
  'body' => '{
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/timeseries/delete/');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeseries/delete/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeseries/delete/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/timeseries/delete/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeseries/delete/"

payload <- "{\n  \"clientToken\": \"\"\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}}/timeseries/delete/")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/timeseries/delete/') do |req|
  req.body = "{\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/timeseries/delete/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/timeseries/delete/

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeseries/delete/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/access-policies/:accessPolicyId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/access-policies/:accessPolicyId")

require "http/client"

url = "{{baseUrl}}/access-policies/:accessPolicyId"

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

var client = new RestClient("{{baseUrl}}/access-policies/:accessPolicyId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/access-policies/:accessPolicyId"

	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/access-policies/:accessPolicyId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/access-policies/:accessPolicyId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/access-policies/:accessPolicyId")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/access-policies/:accessPolicyId');

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}}/access-policies/:accessPolicyId'
};

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

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

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

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

 "{{baseUrl}}/access-policies/:accessPolicyId",
  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}}/access-policies/:accessPolicyId');

echo $response->getBody();

setUrl('{{baseUrl}}/access-policies/:accessPolicyId');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/access-policies/:accessPolicyId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/access-policies/:accessPolicyId' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/access-policies/:accessPolicyId")

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

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/access-policies/:accessPolicyId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/access-policies/:accessPolicyId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/access-policies/:accessPolicyId")

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/access-policies/:accessPolicyId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/access-policies/:accessPolicyId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/access-policies/:accessPolicyId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/access-policies/:accessPolicyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/access-policies/:accessPolicyId")! 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}}/assets/:assetId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets/:assetId")

require "http/client"

url = "{{baseUrl}}/assets/:assetId"

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}}/assets/:assetId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId"

	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/assets/:assetId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets/:assetId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId"))
    .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}}/assets/:assetId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/assets/:assetId")
  .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}}/assets/:assetId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/assets/:assetId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId';
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}}/assets/:assetId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/:assetId',
  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}}/assets/:assetId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/assets/:assetId');

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}}/assets/:assetId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId';
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}}/assets/:assetId"]
                                                       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}}/assets/:assetId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId",
  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}}/assets/:assetId');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/:assetId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets/:assetId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/:assetId")

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/assets/:assetId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/assets/:assetId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/assets/:assetId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId")! 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}}/asset-models/:assetModelId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/asset-models/:assetModelId")

require "http/client"

url = "{{baseUrl}}/asset-models/:assetModelId"

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}}/asset-models/:assetModelId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/asset-models/:assetModelId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/asset-models/:assetModelId"

	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/asset-models/:assetModelId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/asset-models/:assetModelId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/asset-models/:assetModelId"))
    .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}}/asset-models/:assetModelId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/asset-models/:assetModelId")
  .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}}/asset-models/:assetModelId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/asset-models/:assetModelId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/asset-models/:assetModelId';
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}}/asset-models/:assetModelId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/asset-models/:assetModelId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/asset-models/:assetModelId',
  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}}/asset-models/:assetModelId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/asset-models/:assetModelId');

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}}/asset-models/:assetModelId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/asset-models/:assetModelId';
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}}/asset-models/:assetModelId"]
                                                       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}}/asset-models/:assetModelId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/asset-models/:assetModelId",
  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}}/asset-models/:assetModelId');

echo $response->getBody();

setUrl('{{baseUrl}}/asset-models/:assetModelId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/asset-models/:assetModelId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/asset-models/:assetModelId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/asset-models/:assetModelId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/asset-models/:assetModelId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/asset-models/:assetModelId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/asset-models/:assetModelId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/asset-models/:assetModelId")

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/asset-models/:assetModelId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/asset-models/:assetModelId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/asset-models/:assetModelId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/asset-models/:assetModelId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/asset-models/:assetModelId")! 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}}/assets/:assetId/properties/:propertyId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets/:assetId/properties/:propertyId")

require "http/client"

url = "{{baseUrl}}/assets/:assetId/properties/:propertyId"

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}}/assets/:assetId/properties/:propertyId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/properties/:propertyId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId/properties/:propertyId"

	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/assets/:assetId/properties/:propertyId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets/:assetId/properties/:propertyId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/properties/:propertyId"))
    .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}}/assets/:assetId/properties/:propertyId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/assets/:assetId/properties/:propertyId")
  .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}}/assets/:assetId/properties/:propertyId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/assets/:assetId/properties/:propertyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId/properties/:propertyId';
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}}/assets/:assetId/properties/:propertyId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/properties/:propertyId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/:assetId/properties/:propertyId',
  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}}/assets/:assetId/properties/:propertyId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/assets/:assetId/properties/:propertyId');

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}}/assets/:assetId/properties/:propertyId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId/properties/:propertyId';
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}}/assets/:assetId/properties/:propertyId"]
                                                       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}}/assets/:assetId/properties/:propertyId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId/properties/:propertyId",
  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}}/assets/:assetId/properties/:propertyId');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/properties/:propertyId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/:assetId/properties/:propertyId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId/properties/:propertyId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/properties/:propertyId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets/:assetId/properties/:propertyId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId/properties/:propertyId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/properties/:propertyId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/:assetId/properties/:propertyId")

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/assets/:assetId/properties/:propertyId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId/properties/:propertyId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/assets/:assetId/properties/:propertyId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/assets/:assetId/properties/:propertyId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/properties/:propertyId")! 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}}/jobs/:jobId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/jobs/:jobId")

require "http/client"

url = "{{baseUrl}}/jobs/:jobId"

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}}/jobs/:jobId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/jobs/:jobId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/jobs/:jobId"

	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/jobs/:jobId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/jobs/:jobId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs/:jobId"))
    .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}}/jobs/:jobId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/jobs/:jobId")
  .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}}/jobs/:jobId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/jobs/:jobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/jobs/:jobId';
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}}/jobs/:jobId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/jobs/:jobId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jobs/:jobId',
  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}}/jobs/:jobId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/jobs/:jobId');

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}}/jobs/:jobId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/jobs/:jobId';
const options = {method: '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}}/jobs/:jobId"]
                                                       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}}/jobs/:jobId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/jobs/:jobId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/jobs/:jobId');

echo $response->getBody();

setUrl('{{baseUrl}}/jobs/:jobId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/jobs/:jobId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs/:jobId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs/:jobId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/jobs/:jobId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/jobs/:jobId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/jobs/:jobId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jobs/:jobId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/jobs/:jobId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jobs/:jobId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/jobs/:jobId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/jobs/:jobId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jobs/:jobId")! 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}}/dashboards/:dashboardId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboards/:dashboardId")

require "http/client"

url = "{{baseUrl}}/dashboards/:dashboardId"

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}}/dashboards/:dashboardId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dashboards/:dashboardId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboards/:dashboardId"

	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/dashboards/:dashboardId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboards/:dashboardId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboards/:dashboardId"))
    .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}}/dashboards/:dashboardId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/dashboards/:dashboardId")
  .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}}/dashboards/:dashboardId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/dashboards/:dashboardId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/dashboards/:dashboardId';
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}}/dashboards/:dashboardId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboards/:dashboardId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboards/:dashboardId',
  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}}/dashboards/:dashboardId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboards/:dashboardId');

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}}/dashboards/:dashboardId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboards/:dashboardId';
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}}/dashboards/:dashboardId"]
                                                       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}}/dashboards/:dashboardId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/dashboards/:dashboardId",
  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}}/dashboards/:dashboardId');

echo $response->getBody();

setUrl('{{baseUrl}}/dashboards/:dashboardId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/dashboards/:dashboardId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboards/:dashboardId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboards/:dashboardId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboards/:dashboardId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/dashboards/:dashboardId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dashboards/:dashboardId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboards/:dashboardId")

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/dashboards/:dashboardId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboards/:dashboardId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/dashboards/:dashboardId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/dashboards/:dashboardId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboards/:dashboardId")! 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}}/configuration/account/encryption");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/configuration/account/encryption")

require "http/client"

url = "{{baseUrl}}/configuration/account/encryption"

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}}/configuration/account/encryption"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/configuration/account/encryption");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/configuration/account/encryption"

	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/configuration/account/encryption HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/configuration/account/encryption")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/configuration/account/encryption"))
    .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}}/configuration/account/encryption")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/configuration/account/encryption")
  .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}}/configuration/account/encryption');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/configuration/account/encryption'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/configuration/account/encryption';
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}}/configuration/account/encryption',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/configuration/account/encryption")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/configuration/account/encryption',
  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}}/configuration/account/encryption'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/configuration/account/encryption');

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}}/configuration/account/encryption'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/configuration/account/encryption';
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}}/configuration/account/encryption"]
                                                       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}}/configuration/account/encryption" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/configuration/account/encryption",
  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}}/configuration/account/encryption');

echo $response->getBody();

setUrl('{{baseUrl}}/configuration/account/encryption');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/configuration/account/encryption');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/configuration/account/encryption' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/configuration/account/encryption' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/configuration/account/encryption")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/configuration/account/encryption"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/configuration/account/encryption"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/configuration/account/encryption")

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/configuration/account/encryption') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/configuration/account/encryption";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/configuration/account/encryption

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/configuration/account/encryption

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/configuration/account/encryption")! 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}}/20200301/gateways/:gatewayId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/20200301/gateways/:gatewayId")

require "http/client"

url = "{{baseUrl}}/20200301/gateways/:gatewayId"

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}}/20200301/gateways/:gatewayId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/20200301/gateways/:gatewayId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/20200301/gateways/:gatewayId"

	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/20200301/gateways/:gatewayId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/20200301/gateways/:gatewayId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/20200301/gateways/:gatewayId"))
    .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}}/20200301/gateways/:gatewayId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/20200301/gateways/:gatewayId")
  .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}}/20200301/gateways/:gatewayId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/20200301/gateways/:gatewayId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/20200301/gateways/:gatewayId';
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}}/20200301/gateways/:gatewayId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/20200301/gateways/:gatewayId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/20200301/gateways/:gatewayId',
  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}}/20200301/gateways/:gatewayId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/20200301/gateways/:gatewayId');

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}}/20200301/gateways/:gatewayId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/20200301/gateways/:gatewayId';
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}}/20200301/gateways/:gatewayId"]
                                                       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}}/20200301/gateways/:gatewayId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/20200301/gateways/:gatewayId",
  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}}/20200301/gateways/:gatewayId');

echo $response->getBody();

setUrl('{{baseUrl}}/20200301/gateways/:gatewayId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/20200301/gateways/:gatewayId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/20200301/gateways/:gatewayId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/20200301/gateways/:gatewayId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/20200301/gateways/:gatewayId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/20200301/gateways/:gatewayId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/20200301/gateways/:gatewayId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/20200301/gateways/:gatewayId")

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/20200301/gateways/:gatewayId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/20200301/gateways/:gatewayId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/20200301/gateways/:gatewayId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/20200301/gateways/:gatewayId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/20200301/gateways/:gatewayId")! 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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")

require "http/client"

url = "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"

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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"

	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/20200301/gateways/:gatewayId/capability/:capabilityNamespace HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"))
    .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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")
  .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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace';
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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/20200301/gateways/:gatewayId/capability/:capabilityNamespace',
  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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace');

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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace';
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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"]
                                                       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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace",
  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}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace');

echo $response->getBody();

setUrl('{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/20200301/gateways/:gatewayId/capability/:capabilityNamespace")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")

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/20200301/gateways/:gatewayId/capability/:capabilityNamespace') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/20200301/gateways/:gatewayId/capability/:capabilityNamespace")! 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}}/logging");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/logging")

require "http/client"

url = "{{baseUrl}}/logging"

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}}/logging"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/logging");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/logging"

	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/logging HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/logging")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/logging"))
    .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}}/logging")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/logging")
  .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}}/logging');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/logging'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/logging';
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}}/logging',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/logging")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/logging',
  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}}/logging'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/logging');

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}}/logging'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/logging';
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}}/logging"]
                                                       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}}/logging" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/logging",
  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}}/logging');

echo $response->getBody();

setUrl('{{baseUrl}}/logging');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/logging');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/logging' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/logging' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/logging")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/logging"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/logging"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/logging")

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/logging') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/logging";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/logging

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/logging

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/logging")! 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}}/portals/:portalId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/portals/:portalId")

require "http/client"

url = "{{baseUrl}}/portals/:portalId"

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}}/portals/:portalId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portals/:portalId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portals/:portalId"

	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/portals/:portalId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/portals/:portalId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portals/:portalId"))
    .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}}/portals/:portalId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/portals/:portalId")
  .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}}/portals/:portalId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/portals/:portalId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portals/:portalId';
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}}/portals/:portalId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/portals/:portalId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portals/:portalId',
  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}}/portals/:portalId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/portals/:portalId');

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}}/portals/:portalId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portals/:portalId';
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}}/portals/:portalId"]
                                                       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}}/portals/:portalId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portals/:portalId",
  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}}/portals/:portalId');

echo $response->getBody();

setUrl('{{baseUrl}}/portals/:portalId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/portals/:portalId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/portals/:portalId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/portals/:portalId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/portals/:portalId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/portals/:portalId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/portals/:portalId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/portals/:portalId")

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/portals/:portalId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/portals/:portalId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/portals/:portalId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/portals/:portalId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/portals/:portalId")! 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}}/projects/:projectId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/projects/:projectId")

require "http/client"

url = "{{baseUrl}}/projects/:projectId"

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}}/projects/:projectId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/projects/:projectId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/projects/:projectId"

	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/projects/:projectId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/projects/:projectId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/projects/:projectId"))
    .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}}/projects/:projectId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/projects/:projectId")
  .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}}/projects/:projectId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/projects/:projectId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/projects/:projectId';
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}}/projects/:projectId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/projects/:projectId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/projects/:projectId',
  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}}/projects/:projectId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/projects/:projectId');

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}}/projects/:projectId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/projects/:projectId';
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}}/projects/:projectId"]
                                                       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}}/projects/:projectId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/projects/:projectId",
  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}}/projects/:projectId');

echo $response->getBody();

setUrl('{{baseUrl}}/projects/:projectId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/projects/:projectId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/projects/:projectId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/projects/:projectId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/projects/:projectId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/projects/:projectId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/projects/:projectId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/projects/:projectId")

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/projects/:projectId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/projects/:projectId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/projects/:projectId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/projects/:projectId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/projects/:projectId")! 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}}/configuration/account/storage");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/configuration/account/storage")

require "http/client"

url = "{{baseUrl}}/configuration/account/storage"

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}}/configuration/account/storage"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/configuration/account/storage");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/configuration/account/storage"

	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/configuration/account/storage HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/configuration/account/storage")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/configuration/account/storage"))
    .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}}/configuration/account/storage")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/configuration/account/storage")
  .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}}/configuration/account/storage');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/configuration/account/storage'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/configuration/account/storage';
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}}/configuration/account/storage',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/configuration/account/storage")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/configuration/account/storage',
  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}}/configuration/account/storage'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/configuration/account/storage');

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}}/configuration/account/storage'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/configuration/account/storage';
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}}/configuration/account/storage"]
                                                       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}}/configuration/account/storage" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/configuration/account/storage",
  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}}/configuration/account/storage');

echo $response->getBody();

setUrl('{{baseUrl}}/configuration/account/storage');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/configuration/account/storage');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/configuration/account/storage' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/configuration/account/storage' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/configuration/account/storage")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/configuration/account/storage"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/configuration/account/storage"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/configuration/account/storage")

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/configuration/account/storage') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/configuration/account/storage";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/configuration/account/storage

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/configuration/account/storage

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/configuration/account/storage")! 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}}/timeseries/describe/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/timeseries/describe/")

require "http/client"

url = "{{baseUrl}}/timeseries/describe/"

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}}/timeseries/describe/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/timeseries/describe/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/timeseries/describe/"

	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/timeseries/describe/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/timeseries/describe/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeseries/describe/"))
    .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}}/timeseries/describe/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/timeseries/describe/")
  .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}}/timeseries/describe/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/timeseries/describe/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/timeseries/describe/';
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}}/timeseries/describe/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/timeseries/describe/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/timeseries/describe/',
  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}}/timeseries/describe/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/timeseries/describe/');

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}}/timeseries/describe/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/timeseries/describe/';
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}}/timeseries/describe/"]
                                                       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}}/timeseries/describe/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/timeseries/describe/",
  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}}/timeseries/describe/');

echo $response->getBody();

setUrl('{{baseUrl}}/timeseries/describe/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/timeseries/describe/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/timeseries/describe/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeseries/describe/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/timeseries/describe/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/timeseries/describe/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeseries/describe/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeseries/describe/")

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/timeseries/describe/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeseries/describe/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/timeseries/describe/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/timeseries/describe/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeseries/describe/")! 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}}/assets/:assetId/disassociate");

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  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/assets/:assetId/disassociate" {:content-type :json
                                                                         :form-params {:hierarchyId ""
                                                                                       :childAssetId ""
                                                                                       :clientToken ""}})

require "http/client"

url = "{{baseUrl}}/assets/:assetId/disassociate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/assets/:assetId/disassociate"),
    Content = new StringContent("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/disassociate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId/disassociate"

	payload := strings.NewReader("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\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/assets/:assetId/disassociate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/assets/:assetId/disassociate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/disassociate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/disassociate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/assets/:assetId/disassociate")
  .header("content-type", "application/json")
  .body("{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  hierarchyId: '',
  childAssetId: '',
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/assets/:assetId/disassociate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/disassociate',
  headers: {'content-type': 'application/json'},
  data: {hierarchyId: '', childAssetId: '', clientToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hierarchyId":"","childAssetId":"","clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/assets/:assetId/disassociate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "hierarchyId": "",\n  "childAssetId": "",\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/disassociate")
  .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/assets/:assetId/disassociate',
  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({hierarchyId: '', childAssetId: '', clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/disassociate',
  headers: {'content-type': 'application/json'},
  body: {hierarchyId: '', childAssetId: '', clientToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/assets/:assetId/disassociate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  hierarchyId: '',
  childAssetId: '',
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/assets/:assetId/disassociate',
  headers: {'content-type': 'application/json'},
  data: {hierarchyId: '', childAssetId: '', clientToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"hierarchyId":"","childAssetId":"","clientToken":""}'
};

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 = @{ @"hierarchyId": @"",
                              @"childAssetId": @"",
                              @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/assets/:assetId/disassociate"]
                                                       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}}/assets/:assetId/disassociate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId/disassociate",
  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([
    'hierarchyId' => '',
    'childAssetId' => '',
    'clientToken' => ''
  ]),
  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}}/assets/:assetId/disassociate', [
  'body' => '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/disassociate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'hierarchyId' => '',
  'childAssetId' => '',
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'hierarchyId' => '',
  'childAssetId' => '',
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/assets/:assetId/disassociate');
$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}}/assets/:assetId/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/assets/:assetId/disassociate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId/disassociate"

payload = {
    "hierarchyId": "",
    "childAssetId": "",
    "clientToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/disassociate"

payload <- "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\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}}/assets/:assetId/disassociate")

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  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/assets/:assetId/disassociate') do |req|
  req.body = "{\n  \"hierarchyId\": \"\",\n  \"childAssetId\": \"\",\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId/disassociate";

    let payload = json!({
        "hierarchyId": "",
        "childAssetId": "",
        "clientToken": ""
    });

    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 '{
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
}' |  \
  http POST {{baseUrl}}/assets/:assetId/disassociate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "hierarchyId": "",\n  "childAssetId": "",\n  "clientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/assets/:assetId/disassociate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "hierarchyId": "",
  "childAssetId": "",
  "clientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/disassociate")! 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}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId");

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  \"clientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId" {:query-params {:alias ""
                                                                                                             :assetId ""
                                                                                                             :propertyId ""}
                                                                                              :content-type :json
                                                                                              :form-params {:clientToken ""}})

require "http/client"

url = "{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"),
    Content = new StringContent("{\n  \"clientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"

	payload := strings.NewReader("{\n  \"clientToken\": \"\"\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/timeseries/disassociate/?alias=&assetId=&propertyId= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "clientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId',
  params: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")
  .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/timeseries/disassociate/?alias=&assetId=&propertyId=',
  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({clientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId',
  qs: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  body: {clientToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId');

req.query({
  alias: '',
  assetId: '',
  propertyId: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clientToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId',
  params: {alias: '', assetId: '', propertyId: ''},
  headers: {'content-type': 'application/json'},
  data: {clientToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"clientToken":""}'
};

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 = @{ @"clientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId"]
                                                       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}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => ''
  ]),
  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}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId', [
  'body' => '{
  "clientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'alias' => '',
  'assetId' => '',
  'propertyId' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'alias' => '',
  'assetId' => '',
  'propertyId' => ''
]));

$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}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clientToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/timeseries/disassociate/?alias=&assetId=&propertyId=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId"

querystring = {"alias":"","assetId":"","propertyId":""}

payload = { "clientToken": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId"

queryString <- list(
  alias = "",
  assetId = "",
  propertyId = ""
)

payload <- "{\n  \"clientToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")

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  \"clientToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/timeseries/disassociate/') do |req|
  req.params['alias'] = ''
  req.params['assetId'] = ''
  req.params['propertyId'] = ''
  req.body = "{\n  \"clientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/timeseries/disassociate/#alias&assetId&propertyId";

    let querystring = [
        ("alias", ""),
        ("assetId", ""),
        ("propertyId", ""),
    ];

    let payload = json!({"clientToken": ""});

    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)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "clientToken": ""
}' |  \
  http POST '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["clientToken": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timeseries/disassociate/?alias=&assetId=&propertyId=#alias&assetId&propertyId")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate" {:query-params {:aggregateTypes ""
                                                                                                                            :resolution ""
                                                                                                                            :startDate ""
                                                                                                                            :endDate ""}})

require "http/client"

url = "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate"

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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate"

	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/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate"))
    .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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")
  .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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate',
  params: {aggregateTypes: '', resolution: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate';
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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=',
  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}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate',
  qs: {aggregateTypes: '', resolution: '', startDate: '', endDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate');

req.query({
  aggregateTypes: '',
  resolution: '',
  startDate: '',
  endDate: ''
});

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}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate',
  params: {aggregateTypes: '', resolution: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate';
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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate"]
                                                       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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate",
  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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate');

echo $response->getBody();

setUrl('{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'aggregateTypes' => '',
  'resolution' => '',
  'startDate' => '',
  'endDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'aggregateTypes' => '',
  'resolution' => '',
  'startDate' => '',
  'endDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate"

querystring = {"aggregateTypes":"","resolution":"","startDate":"","endDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate"

queryString <- list(
  aggregateTypes = "",
  resolution = "",
  startDate = "",
  endDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")

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/properties/aggregates') do |req|
  req.params['aggregateTypes'] = ''
  req.params['resolution'] = ''
  req.params['startDate'] = ''
  req.params['endDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/properties/aggregates#aggregateTypes&resolution&startDate&endDate";

    let querystring = [
        ("aggregateTypes", ""),
        ("resolution", ""),
        ("startDate", ""),
        ("endDate", ""),
    ];

    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}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/properties/aggregates?aggregateTypes=&resolution=&startDate=&endDate=#aggregateTypes&resolution&startDate&endDate")! 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}}/properties/latest");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/properties/latest")

require "http/client"

url = "{{baseUrl}}/properties/latest"

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}}/properties/latest"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties/latest");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/properties/latest"

	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/properties/latest HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/properties/latest")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/latest"))
    .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}}/properties/latest")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/properties/latest")
  .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}}/properties/latest');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/properties/latest'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/properties/latest';
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}}/properties/latest',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/properties/latest")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/properties/latest',
  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}}/properties/latest'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/properties/latest');

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}}/properties/latest'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/properties/latest';
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}}/properties/latest"]
                                                       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}}/properties/latest" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/properties/latest",
  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}}/properties/latest');

echo $response->getBody();

setUrl('{{baseUrl}}/properties/latest');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/properties/latest');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/properties/latest' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/latest' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/properties/latest")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/properties/latest"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/latest"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/properties/latest")

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/properties/latest') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/properties/latest";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/properties/latest

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/properties/latest

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/properties/latest")! 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}}/properties/history");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/properties/history")

require "http/client"

url = "{{baseUrl}}/properties/history"

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}}/properties/history"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties/history");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/properties/history"

	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/properties/history HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/properties/history")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/history"))
    .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}}/properties/history")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/properties/history")
  .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}}/properties/history');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/properties/history'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/properties/history';
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}}/properties/history',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/properties/history")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/properties/history',
  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}}/properties/history'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/properties/history');

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}}/properties/history'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/properties/history';
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}}/properties/history"]
                                                       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}}/properties/history" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/properties/history",
  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}}/properties/history');

echo $response->getBody();

setUrl('{{baseUrl}}/properties/history');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/properties/history');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/properties/history' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/history' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/properties/history")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/properties/history"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/history"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/properties/history")

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/properties/history') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/properties/history";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/properties/history

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/properties/history

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/properties/history")! 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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type" {:query-params {:startTimeInSeconds ""
                                                                                                                                                     :endTimeInSeconds ""
                                                                                                                                                     :quality ""
                                                                                                                                                     :intervalInSeconds ""
                                                                                                                                                     :type ""}})

require "http/client"

url = "{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"

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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"

	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/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"))
    .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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")
  .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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type',
  params: {
    startTimeInSeconds: '',
    endTimeInSeconds: '',
    quality: '',
    intervalInSeconds: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type';
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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=',
  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}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type',
  qs: {
    startTimeInSeconds: '',
    endTimeInSeconds: '',
    quality: '',
    intervalInSeconds: '',
    type: ''
  }
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type');

req.query({
  startTimeInSeconds: '',
  endTimeInSeconds: '',
  quality: '',
  intervalInSeconds: '',
  type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type',
  params: {
    startTimeInSeconds: '',
    endTimeInSeconds: '',
    quality: '',
    intervalInSeconds: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type';
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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"]
                                                       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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type",
  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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type');

echo $response->getBody();

setUrl('{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'startTimeInSeconds' => '',
  'endTimeInSeconds' => '',
  'quality' => '',
  'intervalInSeconds' => '',
  'type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'startTimeInSeconds' => '',
  'endTimeInSeconds' => '',
  'quality' => '',
  'intervalInSeconds' => '',
  'type' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"

querystring = {"startTimeInSeconds":"","endTimeInSeconds":"","quality":"","intervalInSeconds":"","type":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type"

queryString <- list(
  startTimeInSeconds = "",
  endTimeInSeconds = "",
  quality = "",
  intervalInSeconds = "",
  type = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")

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/properties/interpolated') do |req|
  req.params['startTimeInSeconds'] = ''
  req.params['endTimeInSeconds'] = ''
  req.params['quality'] = ''
  req.params['intervalInSeconds'] = ''
  req.params['type'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/properties/interpolated#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type";

    let querystring = [
        ("startTimeInSeconds", ""),
        ("endTimeInSeconds", ""),
        ("quality", ""),
        ("intervalInSeconds", ""),
        ("type", ""),
    ];

    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}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/properties/interpolated?startTimeInSeconds=&endTimeInSeconds=&quality=&intervalInSeconds=&type=#startTimeInSeconds&endTimeInSeconds&quality&intervalInSeconds&type")! 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}}/access-policies");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/access-policies")

require "http/client"

url = "{{baseUrl}}/access-policies"

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}}/access-policies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/access-policies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/access-policies"

	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/access-policies HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/access-policies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/access-policies"))
    .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}}/access-policies")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/access-policies")
  .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}}/access-policies');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/access-policies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/access-policies';
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}}/access-policies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/access-policies")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/access-policies',
  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}}/access-policies'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/access-policies');

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}}/access-policies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/access-policies';
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}}/access-policies"]
                                                       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}}/access-policies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/access-policies",
  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}}/access-policies');

echo $response->getBody();

setUrl('{{baseUrl}}/access-policies');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/access-policies');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/access-policies' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/access-policies' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/access-policies")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/access-policies"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/access-policies"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/access-policies")

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/access-policies') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/access-policies";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/access-policies

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/access-policies

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/access-policies")! 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}}/asset-models/:assetModelId/properties");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/asset-models/:assetModelId/properties")

require "http/client"

url = "{{baseUrl}}/asset-models/:assetModelId/properties"

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}}/asset-models/:assetModelId/properties"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/asset-models/:assetModelId/properties");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/asset-models/:assetModelId/properties"

	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/asset-models/:assetModelId/properties HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/asset-models/:assetModelId/properties")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/asset-models/:assetModelId/properties"))
    .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}}/asset-models/:assetModelId/properties")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/asset-models/:assetModelId/properties")
  .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}}/asset-models/:assetModelId/properties');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/asset-models/:assetModelId/properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/asset-models/:assetModelId/properties';
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}}/asset-models/:assetModelId/properties',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/asset-models/:assetModelId/properties")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/asset-models/:assetModelId/properties',
  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}}/asset-models/:assetModelId/properties'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/asset-models/:assetModelId/properties');

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}}/asset-models/:assetModelId/properties'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/asset-models/:assetModelId/properties';
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}}/asset-models/:assetModelId/properties"]
                                                       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}}/asset-models/:assetModelId/properties" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/asset-models/:assetModelId/properties",
  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}}/asset-models/:assetModelId/properties');

echo $response->getBody();

setUrl('{{baseUrl}}/asset-models/:assetModelId/properties');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/asset-models/:assetModelId/properties');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/asset-models/:assetModelId/properties' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/asset-models/:assetModelId/properties' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/asset-models/:assetModelId/properties")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/asset-models/:assetModelId/properties"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/asset-models/:assetModelId/properties"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/asset-models/:assetModelId/properties")

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/asset-models/:assetModelId/properties') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/asset-models/:assetModelId/properties";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/asset-models/:assetModelId/properties

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/asset-models/:assetModelId/properties

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/asset-models/:assetModelId/properties")! 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}}/asset-models");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/asset-models")

require "http/client"

url = "{{baseUrl}}/asset-models"

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}}/asset-models"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/asset-models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/asset-models"

	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/asset-models HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/asset-models")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/asset-models"))
    .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}}/asset-models")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/asset-models")
  .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}}/asset-models');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/asset-models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/asset-models';
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}}/asset-models',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/asset-models")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/asset-models',
  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}}/asset-models'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/asset-models');

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}}/asset-models'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/asset-models';
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}}/asset-models"]
                                                       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}}/asset-models" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/asset-models",
  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}}/asset-models');

echo $response->getBody();

setUrl('{{baseUrl}}/asset-models');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/asset-models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/asset-models' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/asset-models' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/asset-models")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/asset-models"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/asset-models"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/asset-models")

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/asset-models') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/asset-models";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/asset-models

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/asset-models

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/asset-models")! 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}}/assets/:assetId/properties");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets/:assetId/properties")

require "http/client"

url = "{{baseUrl}}/assets/:assetId/properties"

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}}/assets/:assetId/properties"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/properties");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId/properties"

	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/assets/:assetId/properties HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets/:assetId/properties")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/properties"))
    .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}}/assets/:assetId/properties")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/assets/:assetId/properties")
  .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}}/assets/:assetId/properties');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/assets/:assetId/properties'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId/properties';
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}}/assets/:assetId/properties',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/properties")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/:assetId/properties',
  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}}/assets/:assetId/properties'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/assets/:assetId/properties');

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}}/assets/:assetId/properties'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId/properties';
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}}/assets/:assetId/properties"]
                                                       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}}/assets/:assetId/properties" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId/properties",
  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}}/assets/:assetId/properties');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/properties');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/:assetId/properties');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId/properties' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/properties' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets/:assetId/properties")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId/properties"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/properties"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/:assetId/properties")

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/assets/:assetId/properties') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId/properties";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/assets/:assetId/properties

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/assets/:assetId/properties

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/properties")! 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}}/assets/:assetId/assetRelationships?traversalType=#traversalType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets/:assetId/assetRelationships#traversalType" {:query-params {:traversalType ""}})

require "http/client"

url = "{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType"

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}}/assets/:assetId/assetRelationships?traversalType=#traversalType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType"

	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/assets/:assetId/assetRelationships?traversalType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType"))
    .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}}/assets/:assetId/assetRelationships?traversalType=#traversalType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType")
  .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}}/assets/:assetId/assetRelationships?traversalType=#traversalType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/assets/:assetId/assetRelationships#traversalType',
  params: {traversalType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType';
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}}/assets/:assetId/assetRelationships?traversalType=#traversalType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/:assetId/assetRelationships?traversalType=',
  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}}/assets/:assetId/assetRelationships#traversalType',
  qs: {traversalType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/assets/:assetId/assetRelationships#traversalType');

req.query({
  traversalType: ''
});

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}}/assets/:assetId/assetRelationships#traversalType',
  params: {traversalType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType';
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}}/assets/:assetId/assetRelationships?traversalType=#traversalType"]
                                                       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}}/assets/:assetId/assetRelationships?traversalType=#traversalType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType",
  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}}/assets/:assetId/assetRelationships?traversalType=#traversalType');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/assetRelationships#traversalType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'traversalType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/:assetId/assetRelationships#traversalType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'traversalType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets/:assetId/assetRelationships?traversalType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId/assetRelationships#traversalType"

querystring = {"traversalType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/assetRelationships#traversalType"

queryString <- list(traversalType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType")

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/assets/:assetId/assetRelationships') do |req|
  req.params['traversalType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId/assetRelationships#traversalType";

    let querystring = [
        ("traversalType", ""),
    ];

    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}}/assets/:assetId/assetRelationships?traversalType=#traversalType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/assetRelationships?traversalType=#traversalType")! 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}}/assets");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets")

require "http/client"

url = "{{baseUrl}}/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}}/assets"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/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/assets HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/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}}/assets")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/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}}/assets');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/assets'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/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}}/assets',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/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}}/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}}/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}}/assets'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/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}}/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}}/assets" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/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}}/assets');

echo $response->getBody();

setUrl('{{baseUrl}}/assets');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/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/assets') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/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}}/assets

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/assets

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/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}}/assets/:assetId/hierarchies");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/assets/:assetId/hierarchies")

require "http/client"

url = "{{baseUrl}}/assets/:assetId/hierarchies"

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}}/assets/:assetId/hierarchies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/assets/:assetId/hierarchies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/assets/:assetId/hierarchies"

	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/assets/:assetId/hierarchies HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/assets/:assetId/hierarchies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/assets/:assetId/hierarchies"))
    .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}}/assets/:assetId/hierarchies")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/assets/:assetId/hierarchies")
  .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}}/assets/:assetId/hierarchies');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/assets/:assetId/hierarchies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/assets/:assetId/hierarchies';
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}}/assets/:assetId/hierarchies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/assets/:assetId/hierarchies")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/assets/:assetId/hierarchies',
  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}}/assets/:assetId/hierarchies'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/assets/:assetId/hierarchies');

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}}/assets/:assetId/hierarchies'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/assets/:assetId/hierarchies';
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}}/assets/:assetId/hierarchies"]
                                                       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}}/assets/:assetId/hierarchies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/assets/:assetId/hierarchies",
  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}}/assets/:assetId/hierarchies');

echo $response->getBody();

setUrl('{{baseUrl}}/assets/:assetId/hierarchies');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/assets/:assetId/hierarchies');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/assets/:assetId/hierarchies' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/assets/:assetId/hierarchies' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/assets/:assetId/hierarchies")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/assets/:assetId/hierarchies"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/assets/:assetId/hierarchies"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/assets/:assetId/hierarchies")

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/assets/:assetId/hierarchies') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/assets/:assetId/hierarchies";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/assets/:assetId/hierarchies

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/assets/:assetId/hierarchies

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/assets/:assetId/hierarchies")! 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}}/jobs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/jobs")

require "http/client"

url = "{{baseUrl}}/jobs"

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}}/jobs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/jobs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/jobs"

	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/jobs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/jobs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/jobs"))
    .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}}/jobs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/jobs")
  .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}}/jobs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/jobs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/jobs';
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}}/jobs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/jobs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/jobs',
  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}}/jobs'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/jobs');

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}}/jobs'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/jobs';
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}}/jobs"]
                                                       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}}/jobs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/jobs",
  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}}/jobs');

echo $response->getBody();

setUrl('{{baseUrl}}/jobs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/jobs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/jobs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/jobs' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/jobs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/jobs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/jobs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/jobs")

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/jobs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/jobs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/jobs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/jobs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/jobs")! 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}}/dashboards?projectId=#projectId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/dashboards#projectId" {:query-params {:projectId ""}})

require "http/client"

url = "{{baseUrl}}/dashboards?projectId=#projectId"

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}}/dashboards?projectId=#projectId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/dashboards?projectId=#projectId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/dashboards?projectId=#projectId"

	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/dashboards?projectId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/dashboards?projectId=#projectId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/dashboards?projectId=#projectId"))
    .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}}/dashboards?projectId=#projectId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/dashboards?projectId=#projectId")
  .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}}/dashboards?projectId=#projectId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/dashboards#projectId',
  params: {projectId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/dashboards?projectId=#projectId';
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}}/dashboards?projectId=#projectId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/dashboards?projectId=#projectId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/dashboards?projectId=',
  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}}/dashboards#projectId',
  qs: {projectId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/dashboards#projectId');

req.query({
  projectId: ''
});

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}}/dashboards#projectId',
  params: {projectId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/dashboards?projectId=#projectId';
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}}/dashboards?projectId=#projectId"]
                                                       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}}/dashboards?projectId=#projectId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/dashboards?projectId=#projectId",
  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}}/dashboards?projectId=#projectId');

echo $response->getBody();

setUrl('{{baseUrl}}/dashboards#projectId');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'projectId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/dashboards#projectId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'projectId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/dashboards?projectId=#projectId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/dashboards?projectId=#projectId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/dashboards?projectId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/dashboards#projectId"

querystring = {"projectId":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/dashboards#projectId"

queryString <- list(projectId = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/dashboards?projectId=#projectId")

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/dashboards') do |req|
  req.params['projectId'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/dashboards#projectId";

    let querystring = [
        ("projectId", ""),
    ];

    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}}/dashboards?projectId=#projectId'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/dashboards?projectId=#projectId'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/dashboards?projectId=#projectId")! 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}}/20200301/gateways");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/20200301/gateways")

require "http/client"

url = "{{baseUrl}}/20200301/gateways"

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}}/20200301/gateways"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/20200301/gateways");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/20200301/gateways"

	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/20200301/gateways HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/20200301/gateways")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/20200301/gateways"))
    .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}}/20200301/gateways")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/20200301/gateways")
  .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}}/20200301/gateways');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/20200301/gateways'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/20200301/gateways';
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}}/20200301/gateways',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/20200301/gateways")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/20200301/gateways',
  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}}/20200301/gateways'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/20200301/gateways');

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}}/20200301/gateways'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/20200301/gateways';
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}}/20200301/gateways"]
                                                       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}}/20200301/gateways" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/20200301/gateways",
  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}}/20200301/gateways');

echo $response->getBody();

setUrl('{{baseUrl}}/20200301/gateways');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/20200301/gateways');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/20200301/gateways' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/20200301/gateways' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/20200301/gateways")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/20200301/gateways"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/20200301/gateways"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/20200301/gateways")

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/20200301/gateways') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/20200301/gateways";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/20200301/gateways

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/20200301/gateways

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/20200301/gateways")! 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}}/portals");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/portals")

require "http/client"

url = "{{baseUrl}}/portals"

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}}/portals"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/portals");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/portals"

	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/portals HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/portals")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/portals"))
    .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}}/portals")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/portals")
  .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}}/portals');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/portals'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/portals';
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}}/portals',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/portals")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/portals',
  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}}/portals'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/portals');

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}}/portals'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/portals';
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}}/portals"]
                                                       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}}/portals" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/portals",
  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}}/portals');

echo $response->getBody();

setUrl('{{baseUrl}}/portals');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/portals');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/portals' -Method GET