CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/register");

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  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/register" {:content-type :json
                                                            :form-params {:account_only false
                                                                          :allow_mist false
                                                                          :email ""
                                                                          :first_name ""
                                                                          :invite_code ""
                                                                          :last_name ""
                                                                          :org_name ""
                                                                          :password ""
                                                                          :recaptcha ""
                                                                          :referer_invite_token ""
                                                                          :return_to ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/register"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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}}/api/v1/register"),
    Content = new StringContent("{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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}}/api/v1/register");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/register"

	payload := strings.NewReader("{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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/api/v1/register HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 229

{
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/register")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/register"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/register")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/register")
  .header("content-type", "application/json")
  .body("{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  account_only: false,
  allow_mist: false,
  email: '',
  first_name: '',
  invite_code: '',
  last_name: '',
  org_name: '',
  password: '',
  recaptcha: '',
  referer_invite_token: '',
  return_to: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/register',
  headers: {'content-type': 'application/json'},
  data: {
    account_only: false,
    allow_mist: false,
    email: '',
    first_name: '',
    invite_code: '',
    last_name: '',
    org_name: '',
    password: '',
    recaptcha: '',
    referer_invite_token: '',
    return_to: ''
  }
};

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

const url = '{{baseUrl}}/api/v1/register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account_only":false,"allow_mist":false,"email":"","first_name":"","invite_code":"","last_name":"","org_name":"","password":"","recaptcha":"","referer_invite_token":"","return_to":""}'
};

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}}/api/v1/register',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "account_only": false,\n  "allow_mist": false,\n  "email": "",\n  "first_name": "",\n  "invite_code": "",\n  "last_name": "",\n  "org_name": "",\n  "password": "",\n  "recaptcha": "",\n  "referer_invite_token": "",\n  "return_to": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/register")
  .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/api/v1/register',
  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({
  account_only: false,
  allow_mist: false,
  email: '',
  first_name: '',
  invite_code: '',
  last_name: '',
  org_name: '',
  password: '',
  recaptcha: '',
  referer_invite_token: '',
  return_to: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/register',
  headers: {'content-type': 'application/json'},
  body: {
    account_only: false,
    allow_mist: false,
    email: '',
    first_name: '',
    invite_code: '',
    last_name: '',
    org_name: '',
    password: '',
    recaptcha: '',
    referer_invite_token: '',
    return_to: ''
  },
  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}}/api/v1/register');

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

req.type('json');
req.send({
  account_only: false,
  allow_mist: false,
  email: '',
  first_name: '',
  invite_code: '',
  last_name: '',
  org_name: '',
  password: '',
  recaptcha: '',
  referer_invite_token: '',
  return_to: ''
});

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}}/api/v1/register',
  headers: {'content-type': 'application/json'},
  data: {
    account_only: false,
    allow_mist: false,
    email: '',
    first_name: '',
    invite_code: '',
    last_name: '',
    org_name: '',
    password: '',
    recaptcha: '',
    referer_invite_token: '',
    return_to: ''
  }
};

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

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

const url = '{{baseUrl}}/api/v1/register';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"account_only":false,"allow_mist":false,"email":"","first_name":"","invite_code":"","last_name":"","org_name":"","password":"","recaptcha":"","referer_invite_token":"","return_to":""}'
};

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 = @{ @"account_only": @NO,
                              @"allow_mist": @NO,
                              @"email": @"",
                              @"first_name": @"",
                              @"invite_code": @"",
                              @"last_name": @"",
                              @"org_name": @"",
                              @"password": @"",
                              @"recaptcha": @"",
                              @"referer_invite_token": @"",
                              @"return_to": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/register"]
                                                       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}}/api/v1/register" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}" in

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

 "{{baseUrl}}/api/v1/register",
  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([
    'account_only' => null,
    'allow_mist' => null,
    'email' => '',
    'first_name' => '',
    'invite_code' => '',
    'last_name' => '',
    'org_name' => '',
    'password' => '',
    'recaptcha' => '',
    'referer_invite_token' => '',
    'return_to' => ''
  ]),
  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}}/api/v1/register', [
  'body' => '{
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/register');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'account_only' => null,
  'allow_mist' => null,
  'email' => '',
  'first_name' => '',
  'invite_code' => '',
  'last_name' => '',
  'org_name' => '',
  'password' => '',
  'recaptcha' => '',
  'referer_invite_token' => '',
  'return_to' => ''
]));

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

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

append(json_encode([
  'account_only' => null,
  'allow_mist' => null,
  'email' => '',
  'first_name' => '',
  'invite_code' => '',
  'last_name' => '',
  'org_name' => '',
  'password' => '',
  'recaptcha' => '',
  'referer_invite_token' => '',
  'return_to' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/register');
$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}}/api/v1/register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/register' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
}'

import http.client

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

payload = "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/api/v1/register"

payload = {
    "account_only": False,
    "allow_mist": False,
    "email": "",
    "first_name": "",
    "invite_code": "",
    "last_name": "",
    "org_name": "",
    "password": "",
    "recaptcha": "",
    "referer_invite_token": "",
    "return_to": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/register"

payload <- "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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}}/api/v1/register")

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  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\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/api/v1/register') do |req|
  req.body = "{\n  \"account_only\": false,\n  \"allow_mist\": false,\n  \"email\": \"\",\n  \"first_name\": \"\",\n  \"invite_code\": \"\",\n  \"last_name\": \"\",\n  \"org_name\": \"\",\n  \"password\": \"\",\n  \"recaptcha\": \"\",\n  \"referer_invite_token\": \"\",\n  \"return_to\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "account_only": false,
        "allow_mist": false,
        "email": "",
        "first_name": "",
        "invite_code": "",
        "last_name": "",
        "org_name": "",
        "password": "",
        "recaptcha": "",
        "referer_invite_token": "",
        "return_to": ""
    });

    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 '{
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
}' |  \
  http POST {{baseUrl}}/api/v1/register \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "account_only": false,\n  "allow_mist": false,\n  "email": "",\n  "first_name": "",\n  "invite_code": "",\n  "last_name": "",\n  "org_name": "",\n  "password": "",\n  "recaptcha": "",\n  "referer_invite_token": "",\n  "return_to": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/register

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "account_only": false,
  "allow_mist": false,
  "email": "",
  "first_name": "",
  "invite_code": "",
  "last_name": "",
  "org_name": "",
  "password": "",
  "recaptcha": "",
  "referer_invite_token": "",
  "return_to": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/register")! 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}}/api/v1/invite/verify/:token");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/invite/verify/:token")

require "http/client"

url = "{{baseUrl}}/api/v1/invite/verify/:token"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/invite/verify/:token"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/invite/verify/:token");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/invite/verify/:token"

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

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

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

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

}

POST /baseUrl/api/v1/invite/verify/:token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/invite/verify/:token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/invite/verify/:token"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/invite/verify/:token")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/invite/verify/:token")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/invite/verify/:token');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/v1/invite/verify/:token'};

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

const url = '{{baseUrl}}/api/v1/invite/verify/:token';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/invite/verify/:token',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/invite/verify/:token")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/invite/verify/:token',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/api/v1/invite/verify/:token'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/invite/verify/:token');

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}}/api/v1/invite/verify/:token'};

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

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

const url = '{{baseUrl}}/api/v1/invite/verify/:token';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/invite/verify/:token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/invite/verify/:token" in

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

 "{{baseUrl}}/api/v1/invite/verify/:token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/invite/verify/:token');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/invite/verify/:token');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/api/v1/invite/verify/:token');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/invite/verify/:token' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/invite/verify/:token' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/api/v1/invite/verify/:token")

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

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

import requests

url = "{{baseUrl}}/api/v1/invite/verify/:token"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/invite/verify/:token"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/invite/verify/:token")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/api/v1/invite/verify/:token') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/invite/verify/:token";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/api/v1/invite/verify/:token

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/v1/invite/verify/:token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/invite/verify/:token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/register/verify/:token");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/register/verify/:token")

require "http/client"

url = "{{baseUrl}}/api/v1/register/verify/:token"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/register/verify/:token"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/register/verify/:token");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/register/verify/:token"

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

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

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

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

}

POST /baseUrl/api/v1/register/verify/:token HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/register/verify/:token")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/register/verify/:token"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/register/verify/:token")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/register/verify/:token")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/register/verify/:token');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/register/verify/:token'
};

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

const url = '{{baseUrl}}/api/v1/register/verify/:token';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/register/verify/:token',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/register/verify/:token")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/register/verify/:token',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/register/verify/:token'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/register/verify/:token');

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}}/api/v1/register/verify/:token'
};

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

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

const url = '{{baseUrl}}/api/v1/register/verify/:token';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/register/verify/:token"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/register/verify/:token" in

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

 "{{baseUrl}}/api/v1/register/verify/:token",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/register/verify/:token');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/register/verify/:token');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/api/v1/register/verify/:token');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/register/verify/:token' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/register/verify/:token' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/api/v1/register/verify/:token")

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

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

import requests

url = "{{baseUrl}}/api/v1/register/verify/:token"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/register/verify/:token"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/register/verify/:token")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/api/v1/register/verify/:token') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/register/verify/:token";

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

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

    dbg!(results);
}

http POST {{baseUrl}}/api/v1/register/verify/:token

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/v1/register/verify/:token

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/register/verify/:token")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/self/apitokens");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/self/apitokens" {:content-type :json
                                                                  :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/self/apitokens"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/api/v1/self/apitokens");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/self/apitokens"

	payload := strings.NewReader("{\n  \"name\": \"\"\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/api/v1/self/apitokens HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/self/apitokens")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/self/apitokens"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/self/apitokens")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/self/apitokens")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/self/apitokens');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/self/apitokens',
  headers: {'content-type': 'application/json'},
  data: {name: ''}
};

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

const url = '{{baseUrl}}/api/v1/self/apitokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/self/apitokens',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/self/apitokens")
  .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/api/v1/self/apitokens',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/self/apitokens',
  headers: {'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/self/apitokens');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/self/apitokens',
  headers: {'content-type': 'application/json'},
  data: {name: ''}
};

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

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

const url = '{{baseUrl}}/api/v1/self/apitokens';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/api/v1/self/apitokens",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/self/apitokens', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/self/apitokens');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/self/apitokens');
$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}}/api/v1/self/apitokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/self/apitokens' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/api/v1/self/apitokens", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/self/apitokens"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/self/apitokens"

payload <- "{\n  \"name\": \"\"\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}}/api/v1/self/apitokens")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

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/api/v1/self/apitokens') do |req|
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

echo '{
  "name": ""
}' |  \
  http POST {{baseUrl}}/api/v1/self/apitokens \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/self/apitokens

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/self/apitokens")! 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}}/api/v1/self/apitokens/:apitoken_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")

require "http/client"

url = "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id"

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

var client = new RestClient("{{baseUrl}}/api/v1/self/apitokens/:apitoken_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id"

	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/api/v1/self/apitokens/:apitoken_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")
  .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}}/api/v1/self/apitokens/:apitoken_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id'
};

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

const url = '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id';
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}}/api/v1/self/apitokens/:apitoken_id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id');

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}}/api/v1/self/apitokens/:apitoken_id'
};

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

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

const url = '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id';
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}}/api/v1/self/apitokens/:apitoken_id"]
                                                       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}}/api/v1/self/apitokens/:apitoken_id" in

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

 "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id",
  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}}/api/v1/self/apitokens/:apitoken_id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/self/apitokens/:apitoken_id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/v1/self/apitokens/:apitoken_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/self/apitokens/:apitoken_id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/api/v1/self/apitokens/:apitoken_id")

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

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

import requests

url = "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")

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/api/v1/self/apitokens/:apitoken_id') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id";

    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}}/api/v1/self/apitokens/:apitoken_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/v1/self/apitokens/:apitoken_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/self/apitokens/:apitoken_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/self/apitokens");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/self/apitokens")

require "http/client"

url = "{{baseUrl}}/api/v1/self/apitokens"

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

var client = new RestClient("{{baseUrl}}/api/v1/self/apitokens");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/self/apitokens"

	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/api/v1/self/apitokens HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/self/apitokens")
  .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}}/api/v1/self/apitokens');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/self/apitokens'};

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

const url = '{{baseUrl}}/api/v1/self/apitokens';
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}}/api/v1/self/apitokens',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/self/apitokens")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/self/apitokens');

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}}/api/v1/self/apitokens'};

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

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

const url = '{{baseUrl}}/api/v1/self/apitokens';
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}}/api/v1/self/apitokens"]
                                                       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}}/api/v1/self/apitokens" in

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

 "{{baseUrl}}/api/v1/self/apitokens",
  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}}/api/v1/self/apitokens');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/self/apitokens');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/self/apitokens');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/self/apitokens' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/self/apitokens' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/self/apitokens")

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

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

import requests

url = "{{baseUrl}}/api/v1/self/apitokens"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/self/apitokens"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/self/apitokens")

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/api/v1/self/apitokens') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/self/apitokens

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/self/apitokens

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/self/apitokens")! 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}}/api/v1/const/alarm_defs");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/alarm_defs")

require "http/client"

url = "{{baseUrl}}/api/v1/const/alarm_defs"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/alarm_defs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/alarm_defs"

	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/api/v1/const/alarm_defs HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/alarm_defs")
  .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}}/api/v1/const/alarm_defs');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/alarm_defs'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/alarm_defs")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/alarm_defs');

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}}/api/v1/const/alarm_defs'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/alarm_defs",
  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}}/api/v1/const/alarm_defs');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/alarm_defs');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/alarm_defs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/alarm_defs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/alarm_defs' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/alarm_defs")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/alarm_defs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/alarm_defs"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/alarm_defs")

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/api/v1/const/alarm_defs') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/alarm_defs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/alarm_defs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/alarm_defs")! 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}}/api/v1/const/ap_channels");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/ap_channels")

require "http/client"

url = "{{baseUrl}}/api/v1/const/ap_channels"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/ap_channels");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/ap_channels"

	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/api/v1/const/ap_channels HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/ap_channels")
  .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}}/api/v1/const/ap_channels');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/ap_channels'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/ap_channels")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/ap_channels');

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}}/api/v1/const/ap_channels'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/ap_channels",
  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}}/api/v1/const/ap_channels');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/ap_channels');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/ap_channels');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/ap_channels' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/ap_channels' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/ap_channels")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/ap_channels"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/ap_channels"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/ap_channels")

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/api/v1/const/ap_channels') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/ap_channels

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/ap_channels

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/ap_channels")! 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}}/api/v1/const/ap_led_status");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/ap_led_status")

require "http/client"

url = "{{baseUrl}}/api/v1/const/ap_led_status"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/ap_led_status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/ap_led_status"

	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/api/v1/const/ap_led_status HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/ap_led_status")
  .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}}/api/v1/const/ap_led_status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/ap_led_status'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/ap_led_status")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/ap_led_status');

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}}/api/v1/const/ap_led_status'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/ap_led_status",
  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}}/api/v1/const/ap_led_status');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/ap_led_status');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/ap_led_status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/ap_led_status' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/ap_led_status' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/ap_led_status")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/ap_led_status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/ap_led_status"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/ap_led_status")

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/api/v1/const/ap_led_status') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/ap_led_status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/ap_led_status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/ap_led_status")! 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}}/api/v1/const/applications");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/applications")

require "http/client"

url = "{{baseUrl}}/api/v1/const/applications"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/applications");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/applications"

	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/api/v1/const/applications HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/applications")
  .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}}/api/v1/const/applications');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/applications'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/applications")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/applications');

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}}/api/v1/const/applications'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/applications",
  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}}/api/v1/const/applications');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/applications');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/applications');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/applications' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/applications' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/applications")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/applications"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/applications"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/applications")

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/api/v1/const/applications') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/applications

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/applications

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/applications")! 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}}/api/v1/const/call_events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/call_events")

require "http/client"

url = "{{baseUrl}}/api/v1/const/call_events"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/call_events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/call_events"

	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/api/v1/const/call_events HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/call_events")
  .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}}/api/v1/const/call_events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/call_events'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/call_events")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/call_events');

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}}/api/v1/const/call_events'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/call_events",
  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}}/api/v1/const/call_events');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/call_events');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/call_events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/call_events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/call_events' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/call_events")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/call_events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/call_events"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/call_events")

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/api/v1/const/call_events') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/call_events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/call_events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/call_events")! 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}}/api/v1/const/client_events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/client_events")

require "http/client"

url = "{{baseUrl}}/api/v1/const/client_events"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/client_events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/client_events"

	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/api/v1/const/client_events HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/client_events")
  .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}}/api/v1/const/client_events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/client_events'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/client_events")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/client_events');

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}}/api/v1/const/client_events'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/client_events",
  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}}/api/v1/const/client_events');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/client_events');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/client_events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/client_events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/client_events' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/client_events")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/client_events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/client_events"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/client_events")

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/api/v1/const/client_events') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/client_events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/client_events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/client_events")! 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}}/api/v1/const/countries");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/countries")

require "http/client"

url = "{{baseUrl}}/api/v1/const/countries"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/countries");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/countries"

	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/api/v1/const/countries HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/countries")
  .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}}/api/v1/const/countries');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/countries'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/countries")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/countries');

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}}/api/v1/const/countries'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/countries",
  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}}/api/v1/const/countries');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/countries');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/countries');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/countries' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/countries' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/countries")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/countries"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/countries"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/countries")

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/api/v1/const/countries') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/countries

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/countries

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/countries")! 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}}/api/v1/const/device_events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/device_events")

require "http/client"

url = "{{baseUrl}}/api/v1/const/device_events"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/device_events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/device_events"

	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/api/v1/const/device_events HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/device_events")
  .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}}/api/v1/const/device_events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/device_events'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/device_events")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/device_events');

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}}/api/v1/const/device_events'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/device_events",
  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}}/api/v1/const/device_events');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/device_events');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/device_events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/device_events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/device_events' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/device_events")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/device_events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/device_events"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/device_events")

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/api/v1/const/device_events') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/device_events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/device_events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/device_events")! 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}}/api/v1/const/device_models");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/device_models")

require "http/client"

url = "{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/const/device_models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/device_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/api/v1/const/device_models HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/device_models'};

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

const url = '{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/device_models")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_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}}/api/v1/const/device_models" in

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

 "{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/device_models');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/device_models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/device_models' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/device_models' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/device_models")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/device_models"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/device_models"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/device_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/api/v1/const/device_models') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/device_models

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/device_models

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/device_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}}/api/v1/const/default_gateway_config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/default_gateway_config")

require "http/client"

url = "{{baseUrl}}/api/v1/const/default_gateway_config"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/default_gateway_config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/default_gateway_config"

	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/api/v1/const/default_gateway_config HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/default_gateway_config")
  .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}}/api/v1/const/default_gateway_config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/const/default_gateway_config'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/default_gateway_config")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/default_gateway_config');

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}}/api/v1/const/default_gateway_config'
};

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

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

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

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

 "{{baseUrl}}/api/v1/const/default_gateway_config",
  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}}/api/v1/const/default_gateway_config');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/default_gateway_config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/default_gateway_config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/default_gateway_config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/default_gateway_config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/default_gateway_config")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/default_gateway_config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/default_gateway_config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/default_gateway_config")

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/api/v1/const/default_gateway_config') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/default_gateway_config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/default_gateway_config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/default_gateway_config")! 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}}/api/v1/const/mxedge_events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/mxedge_events")

require "http/client"

url = "{{baseUrl}}/api/v1/const/mxedge_events"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/mxedge_events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/mxedge_events"

	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/api/v1/const/mxedge_events HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/mxedge_events")
  .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}}/api/v1/const/mxedge_events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/mxedge_events'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/mxedge_events")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/mxedge_events');

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}}/api/v1/const/mxedge_events'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/mxedge_events",
  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}}/api/v1/const/mxedge_events');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/mxedge_events');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/mxedge_events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/mxedge_events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/mxedge_events' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/mxedge_events")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/mxedge_events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/mxedge_events"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/mxedge_events")

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/api/v1/const/mxedge_events') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/mxedge_events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/mxedge_events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/mxedge_events")! 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}}/api/v1/const/mxedge_models");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/mxedge_models")

require "http/client"

url = "{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/const/mxedge_models");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/mxedge_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/api/v1/const/mxedge_models HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/mxedge_models'};

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

const url = '{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/mxedge_models")
  .get()
  .build()

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

const http = require('https');

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

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

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

const url = '{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models" in

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

 "{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/mxedge_models');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/mxedge_models');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/mxedge_models' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/mxedge_models' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/mxedge_models")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/mxedge_models"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/mxedge_models"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/mxedge_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/api/v1/const/mxedge_models') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/mxedge_models

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/mxedge_models

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/mxedge_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}}/api/v1/const/insight_metrics");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/insight_metrics")

require "http/client"

url = "{{baseUrl}}/api/v1/const/insight_metrics"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/insight_metrics");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/insight_metrics"

	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/api/v1/const/insight_metrics HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/insight_metrics")
  .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}}/api/v1/const/insight_metrics');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/insight_metrics'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/insight_metrics")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/insight_metrics');

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}}/api/v1/const/insight_metrics'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/insight_metrics",
  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}}/api/v1/const/insight_metrics');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/insight_metrics');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/insight_metrics');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/insight_metrics' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/insight_metrics' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/insight_metrics")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/insight_metrics"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/insight_metrics"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/insight_metrics")

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/api/v1/const/insight_metrics') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/insight_metrics

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/insight_metrics

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/insight_metrics")! 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}}/api/v1/const/languages");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/languages")

require "http/client"

url = "{{baseUrl}}/api/v1/const/languages"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/languages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/languages"

	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/api/v1/const/languages HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/languages")
  .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}}/api/v1/const/languages');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/languages'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/languages")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/languages');

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}}/api/v1/const/languages'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/languages",
  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}}/api/v1/const/languages');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/languages');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/languages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/languages' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/languages' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/languages")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/languages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/languages"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/languages")

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/api/v1/const/languages') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/languages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/languages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/languages")! 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}}/api/v1/const/system_events");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/system_events")

require "http/client"

url = "{{baseUrl}}/api/v1/const/system_events"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/system_events");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/system_events"

	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/api/v1/const/system_events HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/system_events")
  .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}}/api/v1/const/system_events');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/system_events'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/system_events")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/system_events');

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}}/api/v1/const/system_events'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/system_events",
  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}}/api/v1/const/system_events');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/system_events');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/system_events');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/system_events' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/system_events' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/system_events")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/system_events"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/system_events"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/system_events")

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/api/v1/const/system_events') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/system_events

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/system_events

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/system_events")! 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}}/api/v1/const/traffic_types");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/const/traffic_types")

require "http/client"

url = "{{baseUrl}}/api/v1/const/traffic_types"

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

var client = new RestClient("{{baseUrl}}/api/v1/const/traffic_types");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/const/traffic_types"

	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/api/v1/const/traffic_types HTTP/1.1
Host: example.com

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

client.close();

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

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/const/traffic_types")
  .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}}/api/v1/const/traffic_types');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/const/traffic_types'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/const/traffic_types")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/const/traffic_types');

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}}/api/v1/const/traffic_types'};

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

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

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

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

 "{{baseUrl}}/api/v1/const/traffic_types",
  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}}/api/v1/const/traffic_types');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/const/traffic_types');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/const/traffic_types');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/const/traffic_types' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/const/traffic_types' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/const/traffic_types")

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

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

import requests

url = "{{baseUrl}}/api/v1/const/traffic_types"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/const/traffic_types"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/const/traffic_types")

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/api/v1/const/traffic_types') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/const/traffic_types

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/const/traffic_types

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/const/traffic_types")! 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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name" {:multipart [{:name "file"
                                                                                                                       :content ""} {:name "json"
                                                                                                                       :content ""}]})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "file",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "json",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

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

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

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

}

POST /baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 193

-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('file', '');
data.append('json', '');

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('file', '');
form.append('json', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name';
const form = new FormData();
form.append('file', '');
form.append('json', '');

const options = {method: 'POST'};

options.body = form;

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

const form = new FormData();
form.append('file', '');
form.append('json', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {file: '', json: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

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

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('file', '');
formData.append('json', '');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"file", @"value": @"" },
                         @{ @"name": @"json", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
');

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

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

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');
$request->setRequestMethod('POST');
$request->setBody($body);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
'

import http.client

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

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name";

    let form = reqwest::multipart::Form::new()
        .text("file", "")
        .text("json", "");
    let mut headers = reqwest::header::HeaderMap::new();

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

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

    dbg!(results);
}

echo '-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'

wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name

import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "file",
    "value": ""
  ],
  [
    "name": "json",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices");

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  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices" {:content-type :json
                                                                                  :form-params [{}]})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

	payload := strings.NewReader("[\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/api/v1/installer/orgs/:org_id/devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .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/api/v1/installer/orgs/:org_id/devices',
  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([{}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices',
  headers: {'content-type': 'application/json'},
  body: [{}],
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');

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

req.type('json');
req.send([
  {}
]);

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"]
                                                       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}}/api/v1/installer/orgs/:org_id/devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');
$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}}/api/v1/installer/orgs/:org_id/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

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

payload = "[\n  {}\n]"

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

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/devices", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

payload <- "[\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}}/api/v1/installer/orgs/:org_id/devices")

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  {}\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/api/v1/installer/orgs/:org_id/devices') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices";

    let payload = (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 '[
  {}
]' |  \
  http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")! 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");

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  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id" {:content-type :json
                                                                                                        :form-params {:flags {}
                                                                                                                      :height 0
                                                                                                                      :latlng_br {:lat "string"
                                                                                                                                  :lng "string"}
                                                                                                                      :latlng_tl {:lat "string"
                                                                                                                                  :lng "string"}
                                                                                                                      :locked true
                                                                                                                      :name "string"
                                                                                                                      :orientation 0
                                                                                                                      :origin_x 0
                                                                                                                      :origin_y 0
                                                                                                                      :ppm 0
                                                                                                                      :sitesurvey_path [{:coordinate "string"
                                                                                                                                         :id "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
                                                                                                                                         :name "string"
                                                                                                                                         :nodes [{:edges {:N2 "string"}
                                                                                                                                                  :name "string"
                                                                                                                                                  :position {:x 0
                                                                                                                                                             :y 0}}]}]
                                                                                                                      :thumbnail_url "string"
                                                                                                                      :type "image"
                                                                                                                      :url "string"
                                                                                                                      :view "roadmap"
                                                                                                                      :wall_path {:coordinate "string"
                                                                                                                                  :nodes [{:edges {:N2 "string"}
                                                                                                                                           :name "string"
                                                                                                                                           :position {:x 0
                                                                                                                                                      :y 0}}]}
                                                                                                                      :wayfinding {:micello {:account_key "string"
                                                                                                                                             :default_level_id 0
                                                                                                                                             :map_id "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"}
                                                                                                                                   :snap_to_path true}
                                                                                                                      :wayfinding_path {:coordinate "string"
                                                                                                                                        :nodes [{:edges {:N2 "string"}
                                                                                                                                                 :name "string"
                                                                                                                                                 :position {:x 0
                                                                                                                                                            :y 0}}]}
                                                                                                                      :width 0}})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"),
    Content = new StringContent("{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

	payload := strings.NewReader("{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1382

{
  "flags": {},
  "height": 0,
  "latlng_br": {
    "lat": "string",
    "lng": "string"
  },
  "latlng_tl": {
    "lat": "string",
    "lng": "string"
  },
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    {
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        {
          "edges": {
            "N2": "string"
          },
          "name": "string",
          "position": {
            "x": 0,
            "y": 0
          }
        }
      ]
    }
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    },
    "snap_to_path": true
  },
  "wayfinding_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "width": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .header("content-type", "application/json")
  .body("{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}")
  .asString();

const data = JSON.stringify({
  flags: {},
  height: 0,
  latlng_br: {
    lat: 'string',
    lng: 'string'
  },
  latlng_tl: {
    lat: 'string',
    lng: 'string'
  },
  locked: true,
  name: 'string',
  orientation: 0,
  origin_x: 0,
  origin_y: 0,
  ppm: 0,
  sitesurvey_path: [
    {
      coordinate: 'string',
      id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
      name: 'string',
      nodes: [
        {
          edges: {
            N2: 'string'
          },
          name: 'string',
          position: {
            x: 0,
            y: 0
          }
        }
      ]
    }
  ],
  thumbnail_url: 'string',
  type: 'image',
  url: 'string',
  view: 'roadmap',
  wall_path: {
    coordinate: 'string',
    nodes: [
      {
        edges: {
          N2: 'string'
        },
        name: 'string',
        position: {
          x: 0,
          y: 0
        }
      }
    ]
  },
  wayfinding: {
    micello: {
      account_key: 'string',
      default_level_id: 0,
      map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
    },
    snap_to_path: true
  },
  wayfinding_path: {
    coordinate: 'string',
    nodes: [
      {
        edges: {
          N2: 'string'
        },
        name: 'string',
        position: {
          x: 0,
          y: 0
        }
      }
    ]
  },
  width: 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  data: {
    flags: {},
    height: 0,
    latlng_br: {lat: 'string', lng: 'string'},
    latlng_tl: {lat: 'string', lng: 'string'},
    locked: true,
    name: 'string',
    orientation: 0,
    origin_x: 0,
    origin_y: 0,
    ppm: 0,
    sitesurvey_path: [
      {
        coordinate: 'string',
        id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
        name: 'string',
        nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
      }
    ],
    thumbnail_url: 'string',
    type: 'image',
    url: 'string',
    view: 'roadmap',
    wall_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    wayfinding: {
      micello: {
        account_key: 'string',
        default_level_id: 0,
        map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
      },
      snap_to_path: true
    },
    wayfinding_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    width: 0
  }
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flags":{},"height":0,"latlng_br":{"lat":"string","lng":"string"},"latlng_tl":{"lat":"string","lng":"string"},"locked":true,"name":"string","orientation":0,"origin_x":0,"origin_y":0,"ppm":0,"sitesurvey_path":[{"coordinate":"string","id":"b069b358-4c97-5319-1f8c-7c5ca64d6ab1","name":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]}],"thumbnail_url":"string","type":"image","url":"string","view":"roadmap","wall_path":{"coordinate":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]},"wayfinding":{"micello":{"account_key":"string","default_level_id":0,"map_id":"b069b358-4c97-5319-1f8c-7c5ca64d6ab1"},"snap_to_path":true},"wayfinding_path":{"coordinate":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]},"width":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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "flags": {},\n  "height": 0,\n  "latlng_br": {\n    "lat": "string",\n    "lng": "string"\n  },\n  "latlng_tl": {\n    "lat": "string",\n    "lng": "string"\n  },\n  "locked": true,\n  "name": "string",\n  "orientation": 0,\n  "origin_x": 0,\n  "origin_y": 0,\n  "ppm": 0,\n  "sitesurvey_path": [\n    {\n      "coordinate": "string",\n      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",\n      "name": "string",\n      "nodes": [\n        {\n          "edges": {\n            "N2": "string"\n          },\n          "name": "string",\n          "position": {\n            "x": 0,\n            "y": 0\n          }\n        }\n      ]\n    }\n  ],\n  "thumbnail_url": "string",\n  "type": "image",\n  "url": "string",\n  "view": "roadmap",\n  "wall_path": {\n    "coordinate": "string",\n    "nodes": [\n      {\n        "edges": {\n          "N2": "string"\n        },\n        "name": "string",\n        "position": {\n          "x": 0,\n          "y": 0\n        }\n      }\n    ]\n  },\n  "wayfinding": {\n    "micello": {\n      "account_key": "string",\n      "default_level_id": 0,\n      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"\n    },\n    "snap_to_path": true\n  },\n  "wayfinding_path": {\n    "coordinate": "string",\n    "nodes": [\n      {\n        "edges": {\n          "N2": "string"\n        },\n        "name": "string",\n        "position": {\n          "x": 0,\n          "y": 0\n        }\n      }\n    ]\n  },\n  "width": 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  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .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/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  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({
  flags: {},
  height: 0,
  latlng_br: {lat: 'string', lng: 'string'},
  latlng_tl: {lat: 'string', lng: 'string'},
  locked: true,
  name: 'string',
  orientation: 0,
  origin_x: 0,
  origin_y: 0,
  ppm: 0,
  sitesurvey_path: [
    {
      coordinate: 'string',
      id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
      name: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    }
  ],
  thumbnail_url: 'string',
  type: 'image',
  url: 'string',
  view: 'roadmap',
  wall_path: {
    coordinate: 'string',
    nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
  },
  wayfinding: {
    micello: {
      account_key: 'string',
      default_level_id: 0,
      map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
    },
    snap_to_path: true
  },
  wayfinding_path: {
    coordinate: 'string',
    nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
  },
  width: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  body: {
    flags: {},
    height: 0,
    latlng_br: {lat: 'string', lng: 'string'},
    latlng_tl: {lat: 'string', lng: 'string'},
    locked: true,
    name: 'string',
    orientation: 0,
    origin_x: 0,
    origin_y: 0,
    ppm: 0,
    sitesurvey_path: [
      {
        coordinate: 'string',
        id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
        name: 'string',
        nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
      }
    ],
    thumbnail_url: 'string',
    type: 'image',
    url: 'string',
    view: 'roadmap',
    wall_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    wayfinding: {
      micello: {
        account_key: 'string',
        default_level_id: 0,
        map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
      },
      snap_to_path: true
    },
    wayfinding_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    width: 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');

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

req.type('json');
req.send({
  flags: {},
  height: 0,
  latlng_br: {
    lat: 'string',
    lng: 'string'
  },
  latlng_tl: {
    lat: 'string',
    lng: 'string'
  },
  locked: true,
  name: 'string',
  orientation: 0,
  origin_x: 0,
  origin_y: 0,
  ppm: 0,
  sitesurvey_path: [
    {
      coordinate: 'string',
      id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
      name: 'string',
      nodes: [
        {
          edges: {
            N2: 'string'
          },
          name: 'string',
          position: {
            x: 0,
            y: 0
          }
        }
      ]
    }
  ],
  thumbnail_url: 'string',
  type: 'image',
  url: 'string',
  view: 'roadmap',
  wall_path: {
    coordinate: 'string',
    nodes: [
      {
        edges: {
          N2: 'string'
        },
        name: 'string',
        position: {
          x: 0,
          y: 0
        }
      }
    ]
  },
  wayfinding: {
    micello: {
      account_key: 'string',
      default_level_id: 0,
      map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
    },
    snap_to_path: true
  },
  wayfinding_path: {
    coordinate: 'string',
    nodes: [
      {
        edges: {
          N2: 'string'
        },
        name: 'string',
        position: {
          x: 0,
          y: 0
        }
      }
    ]
  },
  width: 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  data: {
    flags: {},
    height: 0,
    latlng_br: {lat: 'string', lng: 'string'},
    latlng_tl: {lat: 'string', lng: 'string'},
    locked: true,
    name: 'string',
    orientation: 0,
    origin_x: 0,
    origin_y: 0,
    ppm: 0,
    sitesurvey_path: [
      {
        coordinate: 'string',
        id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
        name: 'string',
        nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
      }
    ],
    thumbnail_url: 'string',
    type: 'image',
    url: 'string',
    view: 'roadmap',
    wall_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    wayfinding: {
      micello: {
        account_key: 'string',
        default_level_id: 0,
        map_id: 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
      },
      snap_to_path: true
    },
    wayfinding_path: {
      coordinate: 'string',
      nodes: [{edges: {N2: 'string'}, name: 'string', position: {x: 0, y: 0}}]
    },
    width: 0
  }
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"flags":{},"height":0,"latlng_br":{"lat":"string","lng":"string"},"latlng_tl":{"lat":"string","lng":"string"},"locked":true,"name":"string","orientation":0,"origin_x":0,"origin_y":0,"ppm":0,"sitesurvey_path":[{"coordinate":"string","id":"b069b358-4c97-5319-1f8c-7c5ca64d6ab1","name":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]}],"thumbnail_url":"string","type":"image","url":"string","view":"roadmap","wall_path":{"coordinate":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]},"wayfinding":{"micello":{"account_key":"string","default_level_id":0,"map_id":"b069b358-4c97-5319-1f8c-7c5ca64d6ab1"},"snap_to_path":true},"wayfinding_path":{"coordinate":"string","nodes":[{"edges":{"N2":"string"},"name":"string","position":{"x":0,"y":0}}]},"width":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 = @{ @"flags": @{  },
                              @"height": @0,
                              @"latlng_br": @{ @"lat": @"string", @"lng": @"string" },
                              @"latlng_tl": @{ @"lat": @"string", @"lng": @"string" },
                              @"locked": @YES,
                              @"name": @"string",
                              @"orientation": @0,
                              @"origin_x": @0,
                              @"origin_y": @0,
                              @"ppm": @0,
                              @"sitesurvey_path": @[ @{ @"coordinate": @"string", @"id": @"b069b358-4c97-5319-1f8c-7c5ca64d6ab1", @"name": @"string", @"nodes": @[ @{ @"edges": @{ @"N2": @"string" }, @"name": @"string", @"position": @{ @"x": @0, @"y": @0 } } ] } ],
                              @"thumbnail_url": @"string",
                              @"type": @"image",
                              @"url": @"string",
                              @"view": @"roadmap",
                              @"wall_path": @{ @"coordinate": @"string", @"nodes": @[ @{ @"edges": @{ @"N2": @"string" }, @"name": @"string", @"position": @{ @"x": @0, @"y": @0 } } ] },
                              @"wayfinding": @{ @"micello": @{ @"account_key": @"string", @"default_level_id": @0, @"map_id": @"b069b358-4c97-5319-1f8c-7c5ca64d6ab1" }, @"snap_to_path": @YES },
                              @"wayfinding_path": @{ @"coordinate": @"string", @"nodes": @[ @{ @"edges": @{ @"N2": @"string" }, @"name": @"string", @"position": @{ @"x": @0, @"y": @0 } } ] },
                              @"width": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"]
                                                       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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id",
  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([
    'flags' => [
        
    ],
    'height' => 0,
    'latlng_br' => [
        'lat' => 'string',
        'lng' => 'string'
    ],
    'latlng_tl' => [
        'lat' => 'string',
        'lng' => 'string'
    ],
    'locked' => null,
    'name' => 'string',
    'orientation' => 0,
    'origin_x' => 0,
    'origin_y' => 0,
    'ppm' => 0,
    'sitesurvey_path' => [
        [
                'coordinate' => 'string',
                'id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
                'name' => 'string',
                'nodes' => [
                                [
                                                                'edges' => [
                                                                                                                                'N2' => 'string'
                                                                ],
                                                                'name' => 'string',
                                                                'position' => [
                                                                                                                                'x' => 0,
                                                                                                                                'y' => 0
                                                                ]
                                ]
                ]
        ]
    ],
    'thumbnail_url' => 'string',
    'type' => 'image',
    'url' => 'string',
    'view' => 'roadmap',
    'wall_path' => [
        'coordinate' => 'string',
        'nodes' => [
                [
                                'edges' => [
                                                                'N2' => 'string'
                                ],
                                'name' => 'string',
                                'position' => [
                                                                'x' => 0,
                                                                'y' => 0
                                ]
                ]
        ]
    ],
    'wayfinding' => [
        'micello' => [
                'account_key' => 'string',
                'default_level_id' => 0,
                'map_id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
        ],
        'snap_to_path' => null
    ],
    'wayfinding_path' => [
        'coordinate' => 'string',
        'nodes' => [
                [
                                'edges' => [
                                                                'N2' => 'string'
                                ],
                                'name' => 'string',
                                'position' => [
                                                                'x' => 0,
                                                                'y' => 0
                                ]
                ]
        ]
    ],
    'width' => 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id', [
  'body' => '{
  "flags": {},
  "height": 0,
  "latlng_br": {
    "lat": "string",
    "lng": "string"
  },
  "latlng_tl": {
    "lat": "string",
    "lng": "string"
  },
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    {
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        {
          "edges": {
            "N2": "string"
          },
          "name": "string",
          "position": {
            "x": 0,
            "y": 0
          }
        }
      ]
    }
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    },
    "snap_to_path": true
  },
  "wayfinding_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "width": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'flags' => [
    
  ],
  'height' => 0,
  'latlng_br' => [
    'lat' => 'string',
    'lng' => 'string'
  ],
  'latlng_tl' => [
    'lat' => 'string',
    'lng' => 'string'
  ],
  'locked' => null,
  'name' => 'string',
  'orientation' => 0,
  'origin_x' => 0,
  'origin_y' => 0,
  'ppm' => 0,
  'sitesurvey_path' => [
    [
        'coordinate' => 'string',
        'id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
        'name' => 'string',
        'nodes' => [
                [
                                'edges' => [
                                                                'N2' => 'string'
                                ],
                                'name' => 'string',
                                'position' => [
                                                                'x' => 0,
                                                                'y' => 0
                                ]
                ]
        ]
    ]
  ],
  'thumbnail_url' => 'string',
  'type' => 'image',
  'url' => 'string',
  'view' => 'roadmap',
  'wall_path' => [
    'coordinate' => 'string',
    'nodes' => [
        [
                'edges' => [
                                'N2' => 'string'
                ],
                'name' => 'string',
                'position' => [
                                'x' => 0,
                                'y' => 0
                ]
        ]
    ]
  ],
  'wayfinding' => [
    'micello' => [
        'account_key' => 'string',
        'default_level_id' => 0,
        'map_id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
    ],
    'snap_to_path' => null
  ],
  'wayfinding_path' => [
    'coordinate' => 'string',
    'nodes' => [
        [
                'edges' => [
                                'N2' => 'string'
                ],
                'name' => 'string',
                'position' => [
                                'x' => 0,
                                'y' => 0
                ]
        ]
    ]
  ],
  'width' => 0
]));

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

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

append(json_encode([
  'flags' => [
    
  ],
  'height' => 0,
  'latlng_br' => [
    'lat' => 'string',
    'lng' => 'string'
  ],
  'latlng_tl' => [
    'lat' => 'string',
    'lng' => 'string'
  ],
  'locked' => null,
  'name' => 'string',
  'orientation' => 0,
  'origin_x' => 0,
  'origin_y' => 0,
  'ppm' => 0,
  'sitesurvey_path' => [
    [
        'coordinate' => 'string',
        'id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1',
        'name' => 'string',
        'nodes' => [
                [
                                'edges' => [
                                                                'N2' => 'string'
                                ],
                                'name' => 'string',
                                'position' => [
                                                                'x' => 0,
                                                                'y' => 0
                                ]
                ]
        ]
    ]
  ],
  'thumbnail_url' => 'string',
  'type' => 'image',
  'url' => 'string',
  'view' => 'roadmap',
  'wall_path' => [
    'coordinate' => 'string',
    'nodes' => [
        [
                'edges' => [
                                'N2' => 'string'
                ],
                'name' => 'string',
                'position' => [
                                'x' => 0,
                                'y' => 0
                ]
        ]
    ]
  ],
  'wayfinding' => [
    'micello' => [
        'account_key' => 'string',
        'default_level_id' => 0,
        'map_id' => 'b069b358-4c97-5319-1f8c-7c5ca64d6ab1'
    ],
    'snap_to_path' => null
  ],
  'wayfinding_path' => [
    'coordinate' => 'string',
    'nodes' => [
        [
                'edges' => [
                                'N2' => 'string'
                ],
                'name' => 'string',
                'position' => [
                                'x' => 0,
                                'y' => 0
                ]
        ]
    ]
  ],
  'width' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flags": {},
  "height": 0,
  "latlng_br": {
    "lat": "string",
    "lng": "string"
  },
  "latlng_tl": {
    "lat": "string",
    "lng": "string"
  },
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    {
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        {
          "edges": {
            "N2": "string"
          },
          "name": "string",
          "position": {
            "x": 0,
            "y": 0
          }
        }
      ]
    }
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    },
    "snap_to_path": true
  },
  "wayfinding_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "width": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "flags": {},
  "height": 0,
  "latlng_br": {
    "lat": "string",
    "lng": "string"
  },
  "latlng_tl": {
    "lat": "string",
    "lng": "string"
  },
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    {
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        {
          "edges": {
            "N2": "string"
          },
          "name": "string",
          "position": {
            "x": 0,
            "y": 0
          }
        }
      ]
    }
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    },
    "snap_to_path": true
  },
  "wayfinding_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "width": 0
}'

import http.client

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

payload = "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}"

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

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

payload = {
    "flags": {},
    "height": 0,
    "latlng_br": {
        "lat": "string",
        "lng": "string"
    },
    "latlng_tl": {
        "lat": "string",
        "lng": "string"
    },
    "locked": True,
    "name": "string",
    "orientation": 0,
    "origin_x": 0,
    "origin_y": 0,
    "ppm": 0,
    "sitesurvey_path": [
        {
            "coordinate": "string",
            "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
            "name": "string",
            "nodes": [
                {
                    "edges": { "N2": "string" },
                    "name": "string",
                    "position": {
                        "x": 0,
                        "y": 0
                    }
                }
            ]
        }
    ],
    "thumbnail_url": "string",
    "type": "image",
    "url": "string",
    "view": "roadmap",
    "wall_path": {
        "coordinate": "string",
        "nodes": [
            {
                "edges": { "N2": "string" },
                "name": "string",
                "position": {
                    "x": 0,
                    "y": 0
                }
            }
        ]
    },
    "wayfinding": {
        "micello": {
            "account_key": "string",
            "default_level_id": 0,
            "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
        },
        "snap_to_path": True
    },
    "wayfinding_path": {
        "coordinate": "string",
        "nodes": [
            {
                "edges": { "N2": "string" },
                "name": "string",
                "position": {
                    "x": 0,
                    "y": 0
                }
            }
        ]
    },
    "width": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

payload <- "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")

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  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 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/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id') do |req|
  req.body = "{\n  \"flags\": {},\n  \"height\": 0,\n  \"latlng_br\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"string\",\n    \"lng\": \"string\"\n  },\n  \"locked\": true,\n  \"name\": \"string\",\n  \"orientation\": 0,\n  \"origin_x\": 0,\n  \"origin_y\": 0,\n  \"ppm\": 0,\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"string\",\n      \"id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\",\n      \"name\": \"string\",\n      \"nodes\": [\n        {\n          \"edges\": {\n            \"N2\": \"string\"\n          },\n          \"name\": \"string\",\n          \"position\": {\n            \"x\": 0,\n            \"y\": 0\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"string\",\n  \"type\": \"image\",\n  \"url\": \"string\",\n  \"view\": \"roadmap\",\n  \"wall_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"string\",\n      \"default_level_id\": 0,\n      \"map_id\": \"b069b358-4c97-5319-1f8c-7c5ca64d6ab1\"\n    },\n    \"snap_to_path\": true\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"string\",\n    \"nodes\": [\n      {\n        \"edges\": {\n          \"N2\": \"string\"\n        },\n        \"name\": \"string\",\n        \"position\": {\n          \"x\": 0,\n          \"y\": 0\n        }\n      }\n    ]\n  },\n  \"width\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id";

    let payload = json!({
        "flags": json!({}),
        "height": 0,
        "latlng_br": json!({
            "lat": "string",
            "lng": "string"
        }),
        "latlng_tl": json!({
            "lat": "string",
            "lng": "string"
        }),
        "locked": true,
        "name": "string",
        "orientation": 0,
        "origin_x": 0,
        "origin_y": 0,
        "ppm": 0,
        "sitesurvey_path": (
            json!({
                "coordinate": "string",
                "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
                "name": "string",
                "nodes": (
                    json!({
                        "edges": json!({"N2": "string"}),
                        "name": "string",
                        "position": json!({
                            "x": 0,
                            "y": 0
                        })
                    })
                )
            })
        ),
        "thumbnail_url": "string",
        "type": "image",
        "url": "string",
        "view": "roadmap",
        "wall_path": json!({
            "coordinate": "string",
            "nodes": (
                json!({
                    "edges": json!({"N2": "string"}),
                    "name": "string",
                    "position": json!({
                        "x": 0,
                        "y": 0
                    })
                })
            )
        }),
        "wayfinding": json!({
            "micello": json!({
                "account_key": "string",
                "default_level_id": 0,
                "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
            }),
            "snap_to_path": true
        }),
        "wayfinding_path": json!({
            "coordinate": "string",
            "nodes": (
                json!({
                    "edges": json!({"N2": "string"}),
                    "name": "string",
                    "position": json!({
                        "x": 0,
                        "y": 0
                    })
                })
            )
        }),
        "width": 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 '{
  "flags": {},
  "height": 0,
  "latlng_br": {
    "lat": "string",
    "lng": "string"
  },
  "latlng_tl": {
    "lat": "string",
    "lng": "string"
  },
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    {
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        {
          "edges": {
            "N2": "string"
          },
          "name": "string",
          "position": {
            "x": 0,
            "y": 0
          }
        }
      ]
    }
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    },
    "snap_to_path": true
  },
  "wayfinding_path": {
    "coordinate": "string",
    "nodes": [
      {
        "edges": {
          "N2": "string"
        },
        "name": "string",
        "position": {
          "x": 0,
          "y": 0
        }
      }
    ]
  },
  "width": 0
}' |  \
  http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "flags": {},\n  "height": 0,\n  "latlng_br": {\n    "lat": "string",\n    "lng": "string"\n  },\n  "latlng_tl": {\n    "lat": "string",\n    "lng": "string"\n  },\n  "locked": true,\n  "name": "string",\n  "orientation": 0,\n  "origin_x": 0,\n  "origin_y": 0,\n  "ppm": 0,\n  "sitesurvey_path": [\n    {\n      "coordinate": "string",\n      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",\n      "name": "string",\n      "nodes": [\n        {\n          "edges": {\n            "N2": "string"\n          },\n          "name": "string",\n          "position": {\n            "x": 0,\n            "y": 0\n          }\n        }\n      ]\n    }\n  ],\n  "thumbnail_url": "string",\n  "type": "image",\n  "url": "string",\n  "view": "roadmap",\n  "wall_path": {\n    "coordinate": "string",\n    "nodes": [\n      {\n        "edges": {\n          "N2": "string"\n        },\n        "name": "string",\n        "position": {\n          "x": 0,\n          "y": 0\n        }\n      }\n    ]\n  },\n  "wayfinding": {\n    "micello": {\n      "account_key": "string",\n      "default_level_id": 0,\n      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"\n    },\n    "snap_to_path": true\n  },\n  "wayfinding_path": {\n    "coordinate": "string",\n    "nodes": [\n      {\n        "edges": {\n          "N2": "string"\n        },\n        "name": "string",\n        "position": {\n          "x": 0,\n          "y": 0\n        }\n      }\n    ]\n  },\n  "width": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "flags": [],
  "height": 0,
  "latlng_br": [
    "lat": "string",
    "lng": "string"
  ],
  "latlng_tl": [
    "lat": "string",
    "lng": "string"
  ],
  "locked": true,
  "name": "string",
  "orientation": 0,
  "origin_x": 0,
  "origin_y": 0,
  "ppm": 0,
  "sitesurvey_path": [
    [
      "coordinate": "string",
      "id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1",
      "name": "string",
      "nodes": [
        [
          "edges": ["N2": "string"],
          "name": "string",
          "position": [
            "x": 0,
            "y": 0
          ]
        ]
      ]
    ]
  ],
  "thumbnail_url": "string",
  "type": "image",
  "url": "string",
  "view": "roadmap",
  "wall_path": [
    "coordinate": "string",
    "nodes": [
      [
        "edges": ["N2": "string"],
        "name": "string",
        "position": [
          "x": 0,
          "y": 0
        ]
      ]
    ]
  ],
  "wayfinding": [
    "micello": [
      "account_key": "string",
      "default_level_id": 0,
      "map_id": "b069b358-4c97-5319-1f8c-7c5ca64d6ab1"
    ],
    "snap_to_path": true
  ],
  "wayfinding_path": [
    "coordinate": "string",
    "nodes": [
      [
        "edges": ["N2": "string"],
        "name": "string",
        "position": [
          "x": 0,
          "y": 0
        ]
      ]
    ]
  ],
  "width": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name" {:content-type :json
                                                                                          :form-params {:address "1601 S. Deanza Blvd., Cupertino, CA, 95014"
                                                                                                        :country_code "US"
                                                                                                        :latlng {:lat 37.295833
                                                                                                                 :lng -122.032946}
                                                                                                        :name "string"
                                                                                                        :rftemplate_name "rftemplate1"
                                                                                                        :sitegroup_names ["sg1" "sg2"]
                                                                                                        :timezone "America/Los_Angeles"}})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"),
    Content = new StringContent("{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\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}}/api/v1/installer/orgs/:org_id/sites/:site_name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"

	payload := strings.NewReader("{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}")

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

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

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

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

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

}

PUT /baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 291

{
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": {
    "lat": 37.295833,
    "lng": -122.032946
  },
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": [
    "sg1",
    "sg2"
  ],
  "timezone": "America/Los_Angeles"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\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  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")
  .header("content-type", "application/json")
  .body("{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}")
  .asString();

const data = JSON.stringify({
  address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
  country_code: 'US',
  latlng: {
    lat: 37.295833,
    lng: -122.032946
  },
  name: 'string',
  rftemplate_name: 'rftemplate1',
  sitegroup_names: [
    'sg1',
    'sg2'
  ],
  timezone: 'America/Los_Angeles'
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name',
  headers: {'content-type': 'application/json'},
  data: {
    address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
    country_code: 'US',
    latlng: {lat: 37.295833, lng: -122.032946},
    name: 'string',
    rftemplate_name: 'rftemplate1',
    sitegroup_names: ['sg1', 'sg2'],
    timezone: 'America/Los_Angeles'
  }
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"address":"1601 S. Deanza Blvd., Cupertino, CA, 95014","country_code":"US","latlng":{"lat":37.295833,"lng":-122.032946},"name":"string","rftemplate_name":"rftemplate1","sitegroup_names":["sg1","sg2"],"timezone":"America/Los_Angeles"}'
};

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}}/api/v1/installer/orgs/:org_id/sites/:site_name',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",\n  "country_code": "US",\n  "latlng": {\n    "lat": 37.295833,\n    "lng": -122.032946\n  },\n  "name": "string",\n  "rftemplate_name": "rftemplate1",\n  "sitegroup_names": [\n    "sg1",\n    "sg2"\n  ],\n  "timezone": "America/Los_Angeles"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
  country_code: 'US',
  latlng: {lat: 37.295833, lng: -122.032946},
  name: 'string',
  rftemplate_name: 'rftemplate1',
  sitegroup_names: ['sg1', 'sg2'],
  timezone: 'America/Los_Angeles'
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name',
  headers: {'content-type': 'application/json'},
  body: {
    address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
    country_code: 'US',
    latlng: {lat: 37.295833, lng: -122.032946},
    name: 'string',
    rftemplate_name: 'rftemplate1',
    sitegroup_names: ['sg1', 'sg2'],
    timezone: 'America/Los_Angeles'
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name');

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

req.type('json');
req.send({
  address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
  country_code: 'US',
  latlng: {
    lat: 37.295833,
    lng: -122.032946
  },
  name: 'string',
  rftemplate_name: 'rftemplate1',
  sitegroup_names: [
    'sg1',
    'sg2'
  ],
  timezone: 'America/Los_Angeles'
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name',
  headers: {'content-type': 'application/json'},
  data: {
    address: '1601 S. Deanza Blvd., Cupertino, CA, 95014',
    country_code: 'US',
    latlng: {lat: 37.295833, lng: -122.032946},
    name: 'string',
    rftemplate_name: 'rftemplate1',
    sitegroup_names: ['sg1', 'sg2'],
    timezone: 'America/Los_Angeles'
  }
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"address":"1601 S. Deanza Blvd., Cupertino, CA, 95014","country_code":"US","latlng":{"lat":37.295833,"lng":-122.032946},"name":"string","rftemplate_name":"rftemplate1","sitegroup_names":["sg1","sg2"],"timezone":"America/Los_Angeles"}'
};

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 = @{ @"address": @"1601 S. Deanza Blvd., Cupertino, CA, 95014",
                              @"country_code": @"US",
                              @"latlng": @{ @"lat": @37.295833, @"lng": @-122.032946 },
                              @"name": @"string",
                              @"rftemplate_name": @"rftemplate1",
                              @"sitegroup_names": @[ @"sg1", @"sg2" ],
                              @"timezone": @"America/Los_Angeles" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'address' => '1601 S. Deanza Blvd., Cupertino, CA, 95014',
    'country_code' => 'US',
    'latlng' => [
        'lat' => 37.295833,
        'lng' => -122.032946
    ],
    'name' => 'string',
    'rftemplate_name' => 'rftemplate1',
    'sitegroup_names' => [
        'sg1',
        'sg2'
    ],
    'timezone' => 'America/Los_Angeles'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name', [
  'body' => '{
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": {
    "lat": 37.295833,
    "lng": -122.032946
  },
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": [
    "sg1",
    "sg2"
  ],
  "timezone": "America/Los_Angeles"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'address' => '1601 S. Deanza Blvd., Cupertino, CA, 95014',
  'country_code' => 'US',
  'latlng' => [
    'lat' => 37.295833,
    'lng' => -122.032946
  ],
  'name' => 'string',
  'rftemplate_name' => 'rftemplate1',
  'sitegroup_names' => [
    'sg1',
    'sg2'
  ],
  'timezone' => 'America/Los_Angeles'
]));

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

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

append(json_encode([
  'address' => '1601 S. Deanza Blvd., Cupertino, CA, 95014',
  'country_code' => 'US',
  'latlng' => [
    'lat' => 37.295833,
    'lng' => -122.032946
  ],
  'name' => 'string',
  'rftemplate_name' => 'rftemplate1',
  'sitegroup_names' => [
    'sg1',
    'sg2'
  ],
  'timezone' => 'America/Los_Angeles'
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": {
    "lat": 37.295833,
    "lng": -122.032946
  },
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": [
    "sg1",
    "sg2"
  ],
  "timezone": "America/Los_Angeles"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": {
    "lat": 37.295833,
    "lng": -122.032946
  },
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": [
    "sg1",
    "sg2"
  ],
  "timezone": "America/Los_Angeles"
}'

import http.client

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

payload = "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}"

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

conn.request("PUT", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"

payload = {
    "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
    "country_code": "US",
    "latlng": {
        "lat": 37.295833,
        "lng": -122.032946
    },
    "name": "string",
    "rftemplate_name": "rftemplate1",
    "sitegroup_names": ["sg1", "sg2"],
    "timezone": "America/Los_Angeles"
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name"

payload <- "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name') do |req|
  req.body = "{\n  \"address\": \"1601 S. Deanza Blvd., Cupertino, CA, 95014\",\n  \"country_code\": \"US\",\n  \"latlng\": {\n    \"lat\": 37.295833,\n    \"lng\": -122.032946\n  },\n  \"name\": \"string\",\n  \"rftemplate_name\": \"rftemplate1\",\n  \"sitegroup_names\": [\n    \"sg1\",\n    \"sg2\"\n  ],\n  \"timezone\": \"America/Los_Angeles\"\n}"
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name";

    let payload = json!({
        "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
        "country_code": "US",
        "latlng": json!({
            "lat": 37.295833,
            "lng": -122.032946
        }),
        "name": "string",
        "rftemplate_name": "rftemplate1",
        "sitegroup_names": ("sg1", "sg2"),
        "timezone": "America/Los_Angeles"
    });

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

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

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

    dbg!(results);
}

echo '{
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": {
    "lat": 37.295833,
    "lng": -122.032946
  },
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": [
    "sg1",
    "sg2"
  ],
  "timezone": "America/Los_Angeles"
}' |  \
  http PUT {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",\n  "country_code": "US",\n  "latlng": {\n    "lat": 37.295833,\n    "lng": -122.032946\n  },\n  "name": "string",\n  "rftemplate_name": "rftemplate1",\n  "sitegroup_names": [\n    "sg1",\n    "sg2"\n  ],\n  "timezone": "America/Los_Angeles"\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "address": "1601 S. Deanza Blvd., Cupertino, CA, 95014",
  "country_code": "US",
  "latlng": [
    "lat": 37.295833,
    "lng": -122.032946
  ],
  "name": "string",
  "rftemplate_name": "rftemplate1",
  "sitegroup_names": ["sg1", "sg2"],
  "timezone": "America/Los_Angeles"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

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

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

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

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

}

DELETE /baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name'
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name'
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/:image_name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

	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/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"))
    .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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id'
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id'
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"]
                                                       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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id",
  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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")

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/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id";

    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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates"

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

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates"

	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/api/v1/installer/orgs/:org_id/alarmtemplates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates"))
    .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}}/api/v1/installer/orgs/:org_id/alarmtemplates")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")
  .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}}/api/v1/installer/orgs/:org_id/alarmtemplates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates'
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates';
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}}/api/v1/installer/orgs/:org_id/alarmtemplates',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/alarmtemplates',
  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}}/api/v1/installer/orgs/:org_id/alarmtemplates'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates');

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}}/api/v1/installer/orgs/:org_id/alarmtemplates'
};

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

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates';
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}}/api/v1/installer/orgs/:org_id/alarmtemplates"]
                                                       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}}/api/v1/installer/orgs/:org_id/alarmtemplates" in

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

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates",
  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}}/api/v1/installer/orgs/:org_id/alarmtemplates');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/alarmtemplates")

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

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

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")

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/api/v1/installer/orgs/:org_id/alarmtemplates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/alarmtemplates")! 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}}/api/v1/installer/orgs/:org_id/deviceprofiles");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles"

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

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles"

	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/api/v1/installer/orgs/:org_id/deviceprofiles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles"))
    .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}}/api/v1/installer/orgs/:org_id/deviceprofiles")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")
  .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}}/api/v1/installer/orgs/:org_id/deviceprofiles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles'
};

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

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles';
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}}/api/v1/installer/orgs/:org_id/deviceprofiles',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/deviceprofiles',
  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}}/api/v1/installer/orgs/:org_id/deviceprofiles'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles');

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}}/api/v1/installer/orgs/:org_id/deviceprofiles'
};

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

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles';
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}}/api/v1/installer/orgs/:org_id/deviceprofiles"]
                                                       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}}/api/v1/installer/orgs/:org_id/deviceprofiles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles",
  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}}/api/v1/installer/orgs/:org_id/deviceprofiles');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/deviceprofiles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")

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/api/v1/installer/orgs/:org_id/deviceprofiles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/deviceprofiles")! 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}}/api/v1/installer/orgs/:org_id/devices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

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}}/api/v1/installer/orgs/:org_id/devices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

	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/api/v1/installer/orgs/:org_id/devices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"))
    .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}}/api/v1/installer/orgs/:org_id/devices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .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}}/api/v1/installer/orgs/:org_id/devices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices';
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}}/api/v1/installer/orgs/:org_id/devices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices',
  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}}/api/v1/installer/orgs/:org_id/devices'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');

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}}/api/v1/installer/orgs/:org_id/devices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices';
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}}/api/v1/installer/orgs/:org_id/devices"]
                                                       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}}/api/v1/installer/orgs/:org_id/devices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices",
  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}}/api/v1/installer/orgs/:org_id/devices');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/devices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")

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/api/v1/installer/orgs/:org_id/devices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/devices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices")! 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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"

	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/api/v1/installer/orgs/:org_id/sites/:site_name/maps HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"))
    .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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")
  .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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps';
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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps',
  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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps');

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps';
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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"]
                                                       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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps",
  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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")

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/api/v1/installer/orgs/:org_id/sites/:site_name/maps') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps")! 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}}/api/v1/installer/orgs/:org_id/rftemplates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates"

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}}/api/v1/installer/orgs/:org_id/rftemplates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates"

	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/api/v1/installer/orgs/:org_id/rftemplates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates"))
    .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}}/api/v1/installer/orgs/:org_id/rftemplates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")
  .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}}/api/v1/installer/orgs/:org_id/rftemplates');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates';
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}}/api/v1/installer/orgs/:org_id/rftemplates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/rftemplates',
  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}}/api/v1/installer/orgs/:org_id/rftemplates'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates');

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}}/api/v1/installer/orgs/:org_id/rftemplates'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates';
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}}/api/v1/installer/orgs/:org_id/rftemplates"]
                                                       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}}/api/v1/installer/orgs/:org_id/rftemplates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates",
  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}}/api/v1/installer/orgs/:org_id/rftemplates');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/rftemplates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")

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/api/v1/installer/orgs/:org_id/rftemplates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/rftemplates")! 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}}/api/v1/installer/orgs/:org_id/secpolicies");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies"

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}}/api/v1/installer/orgs/:org_id/secpolicies"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies"

	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/api/v1/installer/orgs/:org_id/secpolicies HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies"))
    .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}}/api/v1/installer/orgs/:org_id/secpolicies")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")
  .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}}/api/v1/installer/orgs/:org_id/secpolicies');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies';
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}}/api/v1/installer/orgs/:org_id/secpolicies',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/secpolicies',
  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}}/api/v1/installer/orgs/:org_id/secpolicies'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies');

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}}/api/v1/installer/orgs/:org_id/secpolicies'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies';
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}}/api/v1/installer/orgs/:org_id/secpolicies"]
                                                       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}}/api/v1/installer/orgs/:org_id/secpolicies" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies",
  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}}/api/v1/installer/orgs/:org_id/secpolicies');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/secpolicies")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")

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/api/v1/installer/orgs/:org_id/secpolicies') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/secpolicies")! 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}}/api/v1/installer/orgs/:org_id/sitegroups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups"

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}}/api/v1/installer/orgs/:org_id/sitegroups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups"

	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/api/v1/installer/orgs/:org_id/sitegroups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups"))
    .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}}/api/v1/installer/orgs/:org_id/sitegroups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")
  .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}}/api/v1/installer/orgs/:org_id/sitegroups');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups';
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}}/api/v1/installer/orgs/:org_id/sitegroups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sitegroups',
  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}}/api/v1/installer/orgs/:org_id/sitegroups'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups');

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}}/api/v1/installer/orgs/:org_id/sitegroups'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups';
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}}/api/v1/installer/orgs/:org_id/sitegroups"]
                                                       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}}/api/v1/installer/orgs/:org_id/sitegroups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups",
  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}}/api/v1/installer/orgs/:org_id/sitegroups');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/sitegroups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")

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/api/v1/installer/orgs/:org_id/sitegroups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sitegroups")! 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}}/api/v1/installer/orgs/:org_id/sites");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/v1/installer/orgs/:org_id/sites HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/orgs/:org_id/sites")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/v1/installer/orgs/:org_id/sites') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/orgs/:org_id/sites

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import" {:multipart [{:name "csv"
                                                                                                                    :content ""} {:name "file"
                                                                                                                    :content ""} {:name "json"
                                                                                                                    :content ""}]})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "csv",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "file",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "json",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 272

-----011000010111000001101001
Content-Disposition: form-data; name="csv"


-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('csv', '');
data.append('file', '');
data.append('json', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('csv', '');
form.append('file', '');
form.append('json', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import';
const form = new FormData();
form.append('csv', '');
form.append('file', '');
form.append('json', '');

const options = {method: 'POST'};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('csv', '');
form.append('file', '');
form.append('json', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="csv"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {csv: '', file: '', json: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="csv"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('csv', '');
formData.append('file', '');
formData.append('json', '');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"csv", @"value": @"" },
                         @{ @"name": @"file", @"value": @"" },
                         @{ @"name": @"json", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"]
                                                       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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="csv"


-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import');
$request->setRequestMethod('POST');
$request->setBody($body);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="csv"


-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="csv"


-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"csv\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"json\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import";

    let form = reqwest::multipart::Form::new()
        .text("csv", "")
        .text("file", "")
        .text("json", "");
    let mut headers = reqwest::header::HeaderMap::new();

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '-----011000010111000001101001
Content-Disposition: form-data; name="csv"


-----011000010111000001101001
Content-Disposition: form-data; name="file"


-----011000010111000001101001
Content-Disposition: form-data; name="json"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'

wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="csv"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="file"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="json"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import

import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "csv",
    "value": ""
  ],
  [
    "name": "file",
    "value": ""
  ],
  [
    "name": "json",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/import")! 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}}/api/v1/installer/sites/:site_name/optimize");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize"

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}}/api/v1/installer/sites/:site_name/optimize"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/sites/:site_name/optimize");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize"

	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/api/v1/installer/sites/:site_name/optimize HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/sites/:site_name/optimize"))
    .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}}/api/v1/installer/sites/:site_name/optimize")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")
  .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}}/api/v1/installer/sites/:site_name/optimize');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize';
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}}/api/v1/installer/sites/:site_name/optimize',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/sites/:site_name/optimize',
  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}}/api/v1/installer/sites/:site_name/optimize'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize');

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}}/api/v1/installer/sites/:site_name/optimize'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize';
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}}/api/v1/installer/sites/:site_name/optimize"]
                                                       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}}/api/v1/installer/sites/:site_name/optimize" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize",
  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}}/api/v1/installer/sites/:site_name/optimize');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/sites/:site_name/optimize');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/sites/:site_name/optimize');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/sites/:site_name/optimize' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/installer/sites/:site_name/optimize")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")

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/api/v1/installer/sites/:site_name/optimize') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/installer/sites/:site_name/optimize

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/installer/sites/:site_name/optimize

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/sites/:site_name/optimize")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac");

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  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac" {:content-type :json
                                                                                             :form-params {:deviceprofile_name ""
                                                                                                           :for_site false
                                                                                                           :height ""
                                                                                                           :map_id ""
                                                                                                           :name ""
                                                                                                           :orientation ""
                                                                                                           :replacing_mac ""
                                                                                                           :role ""
                                                                                                           :site_id ""
                                                                                                           :site_name ""
                                                                                                           :x ""
                                                                                                           :y ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"),
    Content = new StringContent("{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\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}}/api/v1/installer/orgs/:org_id/devices/:device_mac");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

	payload := strings.NewReader("{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 213

{
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\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  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .header("content-type", "application/json")
  .body("{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deviceprofile_name: '',
  for_site: false,
  height: '',
  map_id: '',
  name: '',
  orientation: '',
  replacing_mac: '',
  role: '',
  site_id: '',
  site_name: '',
  x: '',
  y: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac',
  headers: {'content-type': 'application/json'},
  data: {
    deviceprofile_name: '',
    for_site: false,
    height: '',
    map_id: '',
    name: '',
    orientation: '',
    replacing_mac: '',
    role: '',
    site_id: '',
    site_name: '',
    x: '',
    y: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deviceprofile_name":"","for_site":false,"height":"","map_id":"","name":"","orientation":"","replacing_mac":"","role":"","site_id":"","site_name":"","x":"","y":""}'
};

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deviceprofile_name": "",\n  "for_site": false,\n  "height": "",\n  "map_id": "",\n  "name": "",\n  "orientation": "",\n  "replacing_mac": "",\n  "role": "",\n  "site_id": "",\n  "site_name": "",\n  "x": "",\n  "y": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac',
  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({
  deviceprofile_name: '',
  for_site: false,
  height: '',
  map_id: '',
  name: '',
  orientation: '',
  replacing_mac: '',
  role: '',
  site_id: '',
  site_name: '',
  x: '',
  y: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac',
  headers: {'content-type': 'application/json'},
  body: {
    deviceprofile_name: '',
    for_site: false,
    height: '',
    map_id: '',
    name: '',
    orientation: '',
    replacing_mac: '',
    role: '',
    site_id: '',
    site_name: '',
    x: '',
    y: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deviceprofile_name: '',
  for_site: false,
  height: '',
  map_id: '',
  name: '',
  orientation: '',
  replacing_mac: '',
  role: '',
  site_id: '',
  site_name: '',
  x: '',
  y: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac',
  headers: {'content-type': 'application/json'},
  data: {
    deviceprofile_name: '',
    for_site: false,
    height: '',
    map_id: '',
    name: '',
    orientation: '',
    replacing_mac: '',
    role: '',
    site_id: '',
    site_name: '',
    x: '',
    y: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"deviceprofile_name":"","for_site":false,"height":"","map_id":"","name":"","orientation":"","replacing_mac":"","role":"","site_id":"","site_name":"","x":"","y":""}'
};

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 = @{ @"deviceprofile_name": @"",
                              @"for_site": @NO,
                              @"height": @"",
                              @"map_id": @"",
                              @"name": @"",
                              @"orientation": @"",
                              @"replacing_mac": @"",
                              @"role": @"",
                              @"site_id": @"",
                              @"site_name": @"",
                              @"x": @"",
                              @"y": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'deviceprofile_name' => '',
    'for_site' => null,
    'height' => '',
    'map_id' => '',
    'name' => '',
    'orientation' => '',
    'replacing_mac' => '',
    'role' => '',
    'site_id' => '',
    'site_name' => '',
    'x' => '',
    'y' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac', [
  'body' => '{
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deviceprofile_name' => '',
  'for_site' => null,
  'height' => '',
  'map_id' => '',
  'name' => '',
  'orientation' => '',
  'replacing_mac' => '',
  'role' => '',
  'site_id' => '',
  'site_name' => '',
  'x' => '',
  'y' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deviceprofile_name' => '',
  'for_site' => null,
  'height' => '',
  'map_id' => '',
  'name' => '',
  'orientation' => '',
  'replacing_mac' => '',
  'role' => '',
  'site_id' => '',
  'site_name' => '',
  'x' => '',
  'y' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

payload = {
    "deviceprofile_name": "",
    "for_site": False,
    "height": "",
    "map_id": "",
    "name": "",
    "orientation": "",
    "replacing_mac": "",
    "role": "",
    "site_id": "",
    "site_name": "",
    "x": "",
    "y": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

payload <- "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac') do |req|
  req.body = "{\n  \"deviceprofile_name\": \"\",\n  \"for_site\": false,\n  \"height\": \"\",\n  \"map_id\": \"\",\n  \"name\": \"\",\n  \"orientation\": \"\",\n  \"replacing_mac\": \"\",\n  \"role\": \"\",\n  \"site_id\": \"\",\n  \"site_name\": \"\",\n  \"x\": \"\",\n  \"y\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac";

    let payload = json!({
        "deviceprofile_name": "",
        "for_site": false,
        "height": "",
        "map_id": "",
        "name": "",
        "orientation": "",
        "replacing_mac": "",
        "role": "",
        "site_id": "",
        "site_name": "",
        "x": "",
        "y": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
}' |  \
  http PUT {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "deviceprofile_name": "",\n  "for_site": false,\n  "height": "",\n  "map_id": "",\n  "name": "",\n  "orientation": "",\n  "replacing_mac": "",\n  "role": "",\n  "site_id": "",\n  "site_name": "",\n  "x": "",\n  "y": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "deviceprofile_name": "",
  "for_site": false,
  "height": "",
  "map_id": "",
  "name": "",
  "orientation": "",
  "replacing_mac": "",
  "role": "",
  "site_id": "",
  "site_name": "",
  "x": "",
  "y": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate");

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, "{}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate" {:content-type :json})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"),
    Content = new StringContent("{}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"

	payload := strings.NewReader("{}")

	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/api/v1/installer/orgs/:org_id/devices/:device_mac/locate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 2

{}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")
  .setHeader("content-type", "application/json")
  .setBody("{}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")
  .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/api/v1/installer/orgs/:org_id/devices/:device_mac/locate',
  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({}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate',
  headers: {'content-type': 'application/json'},
  body: {},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate',
  headers: {'content-type': 'application/json'},
  data: {}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{  };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"]
                                                       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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate');
$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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/locate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"

payload = {}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate"

payload <- "{}"

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")

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 = "{}"

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/api/v1/installer/orgs/:org_id/devices/:device_mac/locate') do |req|
  req.body = "{}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate";

    let payload = 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 '{}' |  \
  http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/locate")! 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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate');

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac/unlocate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

	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/api/v1/installer/orgs/:org_id/devices/:device_mac HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"))
    .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}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .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}}/api/v1/installer/orgs/:org_id/devices/:device_mac');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac';
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}}/api/v1/installer/orgs/:org_id/devices/:device_mac',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac',
  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}}/api/v1/installer/orgs/:org_id/devices/:device_mac'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');

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}}/api/v1/installer/orgs/:org_id/devices/:device_mac'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac';
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}}/api/v1/installer/orgs/:org_id/devices/:device_mac"]
                                                       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}}/api/v1/installer/orgs/:org_id/devices/:device_mac" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac",
  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}}/api/v1/installer/orgs/:org_id/devices/:device_mac');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/v1/installer/orgs/:org_id/devices/:device_mac")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")

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/api/v1/installer/orgs/:org_id/devices/:device_mac') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac";

    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}}/api/v1/installer/orgs/:org_id/devices/:device_mac

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/devices/:device_mac")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");

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  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id" {:content-type :json
                                                                                                       :form-params {:created_time ""
                                                                                                                     :flags {}
                                                                                                                     :for_site false
                                                                                                                     :height ""
                                                                                                                     :height_m ""
                                                                                                                     :id ""
                                                                                                                     :latlng_br {:lat ""
                                                                                                                                 :lng ""}
                                                                                                                     :latlng_tl {:lat ""
                                                                                                                                 :lng ""}
                                                                                                                     :locked false
                                                                                                                     :modified_time ""
                                                                                                                     :name ""
                                                                                                                     :occupancy_limit 0
                                                                                                                     :org_id ""
                                                                                                                     :orientation ""
                                                                                                                     :origin_x ""
                                                                                                                     :origin_y ""
                                                                                                                     :ppm ""
                                                                                                                     :site_id ""
                                                                                                                     :sitesurvey_path [{:coordinate ""
                                                                                                                                        :id ""
                                                                                                                                        :name ""
                                                                                                                                        :nodes [{:edges {}
                                                                                                                                                 :name ""
                                                                                                                                                 :position {:x ""
                                                                                                                                                            :y ""}}]}]
                                                                                                                     :thumbnail_url ""
                                                                                                                     :type ""
                                                                                                                     :url ""
                                                                                                                     :use_auto_orientation false
                                                                                                                     :use_auto_placement false
                                                                                                                     :view ""
                                                                                                                     :wall_path {:coordinate ""
                                                                                                                                 :name ""
                                                                                                                                 :nodes [{}]}
                                                                                                                     :wayfinding {:micello {:account_key ""
                                                                                                                                            :default_level_id 0
                                                                                                                                            :map_id ""}
                                                                                                                                  :snap_to_path false}
                                                                                                                     :wayfinding_path {:coordinate ""
                                                                                                                                       :nodes [{}]}
                                                                                                                     :width ""
                                                                                                                     :width_m ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"),
    Content = new StringContent("{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

	payload := strings.NewReader("{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1132

{
  "created_time": "",
  "flags": {},
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": {
    "lat": "",
    "lng": ""
  },
  "latlng_tl": {
    "lat": "",
    "lng": ""
  },
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    {
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        {
          "edges": {},
          "name": "",
          "position": {
            "x": "",
            "y": ""
          }
        }
      ]
    }
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": {
    "coordinate": "",
    "name": "",
    "nodes": [
      {}
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    },
    "snap_to_path": false
  },
  "wayfinding_path": {
    "coordinate": "",
    "nodes": [
      {}
    ]
  },
  "width": "",
  "width_m": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\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  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .header("content-type", "application/json")
  .body("{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  created_time: '',
  flags: {},
  for_site: false,
  height: '',
  height_m: '',
  id: '',
  latlng_br: {
    lat: '',
    lng: ''
  },
  latlng_tl: {
    lat: '',
    lng: ''
  },
  locked: false,
  modified_time: '',
  name: '',
  occupancy_limit: 0,
  org_id: '',
  orientation: '',
  origin_x: '',
  origin_y: '',
  ppm: '',
  site_id: '',
  sitesurvey_path: [
    {
      coordinate: '',
      id: '',
      name: '',
      nodes: [
        {
          edges: {},
          name: '',
          position: {
            x: '',
            y: ''
          }
        }
      ]
    }
  ],
  thumbnail_url: '',
  type: '',
  url: '',
  use_auto_orientation: false,
  use_auto_placement: false,
  view: '',
  wall_path: {
    coordinate: '',
    name: '',
    nodes: [
      {}
    ]
  },
  wayfinding: {
    micello: {
      account_key: '',
      default_level_id: 0,
      map_id: ''
    },
    snap_to_path: false
  },
  wayfinding_path: {
    coordinate: '',
    nodes: [
      {}
    ]
  },
  width: '',
  width_m: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  data: {
    created_time: '',
    flags: {},
    for_site: false,
    height: '',
    height_m: '',
    id: '',
    latlng_br: {lat: '', lng: ''},
    latlng_tl: {lat: '', lng: ''},
    locked: false,
    modified_time: '',
    name: '',
    occupancy_limit: 0,
    org_id: '',
    orientation: '',
    origin_x: '',
    origin_y: '',
    ppm: '',
    site_id: '',
    sitesurvey_path: [
      {
        coordinate: '',
        id: '',
        name: '',
        nodes: [{edges: {}, name: '', position: {x: '', y: ''}}]
      }
    ],
    thumbnail_url: '',
    type: '',
    url: '',
    use_auto_orientation: false,
    use_auto_placement: false,
    view: '',
    wall_path: {coordinate: '', name: '', nodes: [{}]},
    wayfinding: {
      micello: {account_key: '', default_level_id: 0, map_id: ''},
      snap_to_path: false
    },
    wayfinding_path: {coordinate: '', nodes: [{}]},
    width: '',
    width_m: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"created_time":"","flags":{},"for_site":false,"height":"","height_m":"","id":"","latlng_br":{"lat":"","lng":""},"latlng_tl":{"lat":"","lng":""},"locked":false,"modified_time":"","name":"","occupancy_limit":0,"org_id":"","orientation":"","origin_x":"","origin_y":"","ppm":"","site_id":"","sitesurvey_path":[{"coordinate":"","id":"","name":"","nodes":[{"edges":{},"name":"","position":{"x":"","y":""}}]}],"thumbnail_url":"","type":"","url":"","use_auto_orientation":false,"use_auto_placement":false,"view":"","wall_path":{"coordinate":"","name":"","nodes":[{}]},"wayfinding":{"micello":{"account_key":"","default_level_id":0,"map_id":""},"snap_to_path":false},"wayfinding_path":{"coordinate":"","nodes":[{}]},"width":"","width_m":""}'
};

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}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "created_time": "",\n  "flags": {},\n  "for_site": false,\n  "height": "",\n  "height_m": "",\n  "id": "",\n  "latlng_br": {\n    "lat": "",\n    "lng": ""\n  },\n  "latlng_tl": {\n    "lat": "",\n    "lng": ""\n  },\n  "locked": false,\n  "modified_time": "",\n  "name": "",\n  "occupancy_limit": 0,\n  "org_id": "",\n  "orientation": "",\n  "origin_x": "",\n  "origin_y": "",\n  "ppm": "",\n  "site_id": "",\n  "sitesurvey_path": [\n    {\n      "coordinate": "",\n      "id": "",\n      "name": "",\n      "nodes": [\n        {\n          "edges": {},\n          "name": "",\n          "position": {\n            "x": "",\n            "y": ""\n          }\n        }\n      ]\n    }\n  ],\n  "thumbnail_url": "",\n  "type": "",\n  "url": "",\n  "use_auto_orientation": false,\n  "use_auto_placement": false,\n  "view": "",\n  "wall_path": {\n    "coordinate": "",\n    "name": "",\n    "nodes": [\n      {}\n    ]\n  },\n  "wayfinding": {\n    "micello": {\n      "account_key": "",\n      "default_level_id": 0,\n      "map_id": ""\n    },\n    "snap_to_path": false\n  },\n  "wayfinding_path": {\n    "coordinate": "",\n    "nodes": [\n      {}\n    ]\n  },\n  "width": "",\n  "width_m": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  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({
  created_time: '',
  flags: {},
  for_site: false,
  height: '',
  height_m: '',
  id: '',
  latlng_br: {lat: '', lng: ''},
  latlng_tl: {lat: '', lng: ''},
  locked: false,
  modified_time: '',
  name: '',
  occupancy_limit: 0,
  org_id: '',
  orientation: '',
  origin_x: '',
  origin_y: '',
  ppm: '',
  site_id: '',
  sitesurvey_path: [
    {
      coordinate: '',
      id: '',
      name: '',
      nodes: [{edges: {}, name: '', position: {x: '', y: ''}}]
    }
  ],
  thumbnail_url: '',
  type: '',
  url: '',
  use_auto_orientation: false,
  use_auto_placement: false,
  view: '',
  wall_path: {coordinate: '', name: '', nodes: [{}]},
  wayfinding: {
    micello: {account_key: '', default_level_id: 0, map_id: ''},
    snap_to_path: false
  },
  wayfinding_path: {coordinate: '', nodes: [{}]},
  width: '',
  width_m: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  body: {
    created_time: '',
    flags: {},
    for_site: false,
    height: '',
    height_m: '',
    id: '',
    latlng_br: {lat: '', lng: ''},
    latlng_tl: {lat: '', lng: ''},
    locked: false,
    modified_time: '',
    name: '',
    occupancy_limit: 0,
    org_id: '',
    orientation: '',
    origin_x: '',
    origin_y: '',
    ppm: '',
    site_id: '',
    sitesurvey_path: [
      {
        coordinate: '',
        id: '',
        name: '',
        nodes: [{edges: {}, name: '', position: {x: '', y: ''}}]
      }
    ],
    thumbnail_url: '',
    type: '',
    url: '',
    use_auto_orientation: false,
    use_auto_placement: false,
    view: '',
    wall_path: {coordinate: '', name: '', nodes: [{}]},
    wayfinding: {
      micello: {account_key: '', default_level_id: 0, map_id: ''},
      snap_to_path: false
    },
    wayfinding_path: {coordinate: '', nodes: [{}]},
    width: '',
    width_m: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  created_time: '',
  flags: {},
  for_site: false,
  height: '',
  height_m: '',
  id: '',
  latlng_br: {
    lat: '',
    lng: ''
  },
  latlng_tl: {
    lat: '',
    lng: ''
  },
  locked: false,
  modified_time: '',
  name: '',
  occupancy_limit: 0,
  org_id: '',
  orientation: '',
  origin_x: '',
  origin_y: '',
  ppm: '',
  site_id: '',
  sitesurvey_path: [
    {
      coordinate: '',
      id: '',
      name: '',
      nodes: [
        {
          edges: {},
          name: '',
          position: {
            x: '',
            y: ''
          }
        }
      ]
    }
  ],
  thumbnail_url: '',
  type: '',
  url: '',
  use_auto_orientation: false,
  use_auto_placement: false,
  view: '',
  wall_path: {
    coordinate: '',
    name: '',
    nodes: [
      {}
    ]
  },
  wayfinding: {
    micello: {
      account_key: '',
      default_level_id: 0,
      map_id: ''
    },
    snap_to_path: false
  },
  wayfinding_path: {
    coordinate: '',
    nodes: [
      {}
    ]
  },
  width: '',
  width_m: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id',
  headers: {'content-type': 'application/json'},
  data: {
    created_time: '',
    flags: {},
    for_site: false,
    height: '',
    height_m: '',
    id: '',
    latlng_br: {lat: '', lng: ''},
    latlng_tl: {lat: '', lng: ''},
    locked: false,
    modified_time: '',
    name: '',
    occupancy_limit: 0,
    org_id: '',
    orientation: '',
    origin_x: '',
    origin_y: '',
    ppm: '',
    site_id: '',
    sitesurvey_path: [
      {
        coordinate: '',
        id: '',
        name: '',
        nodes: [{edges: {}, name: '', position: {x: '', y: ''}}]
      }
    ],
    thumbnail_url: '',
    type: '',
    url: '',
    use_auto_orientation: false,
    use_auto_placement: false,
    view: '',
    wall_path: {coordinate: '', name: '', nodes: [{}]},
    wayfinding: {
      micello: {account_key: '', default_level_id: 0, map_id: ''},
      snap_to_path: false
    },
    wayfinding_path: {coordinate: '', nodes: [{}]},
    width: '',
    width_m: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"created_time":"","flags":{},"for_site":false,"height":"","height_m":"","id":"","latlng_br":{"lat":"","lng":""},"latlng_tl":{"lat":"","lng":""},"locked":false,"modified_time":"","name":"","occupancy_limit":0,"org_id":"","orientation":"","origin_x":"","origin_y":"","ppm":"","site_id":"","sitesurvey_path":[{"coordinate":"","id":"","name":"","nodes":[{"edges":{},"name":"","position":{"x":"","y":""}}]}],"thumbnail_url":"","type":"","url":"","use_auto_orientation":false,"use_auto_placement":false,"view":"","wall_path":{"coordinate":"","name":"","nodes":[{}]},"wayfinding":{"micello":{"account_key":"","default_level_id":0,"map_id":""},"snap_to_path":false},"wayfinding_path":{"coordinate":"","nodes":[{}]},"width":"","width_m":""}'
};

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 = @{ @"created_time": @"",
                              @"flags": @{  },
                              @"for_site": @NO,
                              @"height": @"",
                              @"height_m": @"",
                              @"id": @"",
                              @"latlng_br": @{ @"lat": @"", @"lng": @"" },
                              @"latlng_tl": @{ @"lat": @"", @"lng": @"" },
                              @"locked": @NO,
                              @"modified_time": @"",
                              @"name": @"",
                              @"occupancy_limit": @0,
                              @"org_id": @"",
                              @"orientation": @"",
                              @"origin_x": @"",
                              @"origin_y": @"",
                              @"ppm": @"",
                              @"site_id": @"",
                              @"sitesurvey_path": @[ @{ @"coordinate": @"", @"id": @"", @"name": @"", @"nodes": @[ @{ @"edges": @{  }, @"name": @"", @"position": @{ @"x": @"", @"y": @"" } } ] } ],
                              @"thumbnail_url": @"",
                              @"type": @"",
                              @"url": @"",
                              @"use_auto_orientation": @NO,
                              @"use_auto_placement": @NO,
                              @"view": @"",
                              @"wall_path": @{ @"coordinate": @"", @"name": @"", @"nodes": @[ @{  } ] },
                              @"wayfinding": @{ @"micello": @{ @"account_key": @"", @"default_level_id": @0, @"map_id": @"" }, @"snap_to_path": @NO },
                              @"wayfinding_path": @{ @"coordinate": @"", @"nodes": @[ @{  } ] },
                              @"width": @"",
                              @"width_m": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'created_time' => '',
    'flags' => [
        
    ],
    'for_site' => null,
    'height' => '',
    'height_m' => '',
    'id' => '',
    'latlng_br' => [
        'lat' => '',
        'lng' => ''
    ],
    'latlng_tl' => [
        'lat' => '',
        'lng' => ''
    ],
    'locked' => null,
    'modified_time' => '',
    'name' => '',
    'occupancy_limit' => 0,
    'org_id' => '',
    'orientation' => '',
    'origin_x' => '',
    'origin_y' => '',
    'ppm' => '',
    'site_id' => '',
    'sitesurvey_path' => [
        [
                'coordinate' => '',
                'id' => '',
                'name' => '',
                'nodes' => [
                                [
                                                                'edges' => [
                                                                                                                                
                                                                ],
                                                                'name' => '',
                                                                'position' => [
                                                                                                                                'x' => '',
                                                                                                                                'y' => ''
                                                                ]
                                ]
                ]
        ]
    ],
    'thumbnail_url' => '',
    'type' => '',
    'url' => '',
    'use_auto_orientation' => null,
    'use_auto_placement' => null,
    'view' => '',
    'wall_path' => [
        'coordinate' => '',
        'name' => '',
        'nodes' => [
                [
                                
                ]
        ]
    ],
    'wayfinding' => [
        'micello' => [
                'account_key' => '',
                'default_level_id' => 0,
                'map_id' => ''
        ],
        'snap_to_path' => null
    ],
    'wayfinding_path' => [
        'coordinate' => '',
        'nodes' => [
                [
                                
                ]
        ]
    ],
    'width' => '',
    'width_m' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id', [
  'body' => '{
  "created_time": "",
  "flags": {},
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": {
    "lat": "",
    "lng": ""
  },
  "latlng_tl": {
    "lat": "",
    "lng": ""
  },
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    {
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        {
          "edges": {},
          "name": "",
          "position": {
            "x": "",
            "y": ""
          }
        }
      ]
    }
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": {
    "coordinate": "",
    "name": "",
    "nodes": [
      {}
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    },
    "snap_to_path": false
  },
  "wayfinding_path": {
    "coordinate": "",
    "nodes": [
      {}
    ]
  },
  "width": "",
  "width_m": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'created_time' => '',
  'flags' => [
    
  ],
  'for_site' => null,
  'height' => '',
  'height_m' => '',
  'id' => '',
  'latlng_br' => [
    'lat' => '',
    'lng' => ''
  ],
  'latlng_tl' => [
    'lat' => '',
    'lng' => ''
  ],
  'locked' => null,
  'modified_time' => '',
  'name' => '',
  'occupancy_limit' => 0,
  'org_id' => '',
  'orientation' => '',
  'origin_x' => '',
  'origin_y' => '',
  'ppm' => '',
  'site_id' => '',
  'sitesurvey_path' => [
    [
        'coordinate' => '',
        'id' => '',
        'name' => '',
        'nodes' => [
                [
                                'edges' => [
                                                                
                                ],
                                'name' => '',
                                'position' => [
                                                                'x' => '',
                                                                'y' => ''
                                ]
                ]
        ]
    ]
  ],
  'thumbnail_url' => '',
  'type' => '',
  'url' => '',
  'use_auto_orientation' => null,
  'use_auto_placement' => null,
  'view' => '',
  'wall_path' => [
    'coordinate' => '',
    'name' => '',
    'nodes' => [
        [
                
        ]
    ]
  ],
  'wayfinding' => [
    'micello' => [
        'account_key' => '',
        'default_level_id' => 0,
        'map_id' => ''
    ],
    'snap_to_path' => null
  ],
  'wayfinding_path' => [
    'coordinate' => '',
    'nodes' => [
        [
                
        ]
    ]
  ],
  'width' => '',
  'width_m' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'created_time' => '',
  'flags' => [
    
  ],
  'for_site' => null,
  'height' => '',
  'height_m' => '',
  'id' => '',
  'latlng_br' => [
    'lat' => '',
    'lng' => ''
  ],
  'latlng_tl' => [
    'lat' => '',
    'lng' => ''
  ],
  'locked' => null,
  'modified_time' => '',
  'name' => '',
  'occupancy_limit' => 0,
  'org_id' => '',
  'orientation' => '',
  'origin_x' => '',
  'origin_y' => '',
  'ppm' => '',
  'site_id' => '',
  'sitesurvey_path' => [
    [
        'coordinate' => '',
        'id' => '',
        'name' => '',
        'nodes' => [
                [
                                'edges' => [
                                                                
                                ],
                                'name' => '',
                                'position' => [
                                                                'x' => '',
                                                                'y' => ''
                                ]
                ]
        ]
    ]
  ],
  'thumbnail_url' => '',
  'type' => '',
  'url' => '',
  'use_auto_orientation' => null,
  'use_auto_placement' => null,
  'view' => '',
  'wall_path' => [
    'coordinate' => '',
    'name' => '',
    'nodes' => [
        [
                
        ]
    ]
  ],
  'wayfinding' => [
    'micello' => [
        'account_key' => '',
        'default_level_id' => 0,
        'map_id' => ''
    ],
    'snap_to_path' => null
  ],
  'wayfinding_path' => [
    'coordinate' => '',
    'nodes' => [
        [
                
        ]
    ]
  ],
  'width' => '',
  'width_m' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "created_time": "",
  "flags": {},
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": {
    "lat": "",
    "lng": ""
  },
  "latlng_tl": {
    "lat": "",
    "lng": ""
  },
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    {
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        {
          "edges": {},
          "name": "",
          "position": {
            "x": "",
            "y": ""
          }
        }
      ]
    }
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": {
    "coordinate": "",
    "name": "",
    "nodes": [
      {}
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    },
    "snap_to_path": false
  },
  "wayfinding_path": {
    "coordinate": "",
    "nodes": [
      {}
    ]
  },
  "width": "",
  "width_m": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "created_time": "",
  "flags": {},
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": {
    "lat": "",
    "lng": ""
  },
  "latlng_tl": {
    "lat": "",
    "lng": ""
  },
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    {
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        {
          "edges": {},
          "name": "",
          "position": {
            "x": "",
            "y": ""
          }
        }
      ]
    }
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": {
    "coordinate": "",
    "name": "",
    "nodes": [
      {}
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    },
    "snap_to_path": false
  },
  "wayfinding_path": {
    "coordinate": "",
    "nodes": [
      {}
    ]
  },
  "width": "",
  "width_m": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

payload = {
    "created_time": "",
    "flags": {},
    "for_site": False,
    "height": "",
    "height_m": "",
    "id": "",
    "latlng_br": {
        "lat": "",
        "lng": ""
    },
    "latlng_tl": {
        "lat": "",
        "lng": ""
    },
    "locked": False,
    "modified_time": "",
    "name": "",
    "occupancy_limit": 0,
    "org_id": "",
    "orientation": "",
    "origin_x": "",
    "origin_y": "",
    "ppm": "",
    "site_id": "",
    "sitesurvey_path": [
        {
            "coordinate": "",
            "id": "",
            "name": "",
            "nodes": [
                {
                    "edges": {},
                    "name": "",
                    "position": {
                        "x": "",
                        "y": ""
                    }
                }
            ]
        }
    ],
    "thumbnail_url": "",
    "type": "",
    "url": "",
    "use_auto_orientation": False,
    "use_auto_placement": False,
    "view": "",
    "wall_path": {
        "coordinate": "",
        "name": "",
        "nodes": [{}]
    },
    "wayfinding": {
        "micello": {
            "account_key": "",
            "default_level_id": 0,
            "map_id": ""
        },
        "snap_to_path": False
    },
    "wayfinding_path": {
        "coordinate": "",
        "nodes": [{}]
    },
    "width": "",
    "width_m": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id"

payload <- "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id') do |req|
  req.body = "{\n  \"created_time\": \"\",\n  \"flags\": {},\n  \"for_site\": false,\n  \"height\": \"\",\n  \"height_m\": \"\",\n  \"id\": \"\",\n  \"latlng_br\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"latlng_tl\": {\n    \"lat\": \"\",\n    \"lng\": \"\"\n  },\n  \"locked\": false,\n  \"modified_time\": \"\",\n  \"name\": \"\",\n  \"occupancy_limit\": 0,\n  \"org_id\": \"\",\n  \"orientation\": \"\",\n  \"origin_x\": \"\",\n  \"origin_y\": \"\",\n  \"ppm\": \"\",\n  \"site_id\": \"\",\n  \"sitesurvey_path\": [\n    {\n      \"coordinate\": \"\",\n      \"id\": \"\",\n      \"name\": \"\",\n      \"nodes\": [\n        {\n          \"edges\": {},\n          \"name\": \"\",\n          \"position\": {\n            \"x\": \"\",\n            \"y\": \"\"\n          }\n        }\n      ]\n    }\n  ],\n  \"thumbnail_url\": \"\",\n  \"type\": \"\",\n  \"url\": \"\",\n  \"use_auto_orientation\": false,\n  \"use_auto_placement\": false,\n  \"view\": \"\",\n  \"wall_path\": {\n    \"coordinate\": \"\",\n    \"name\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"wayfinding\": {\n    \"micello\": {\n      \"account_key\": \"\",\n      \"default_level_id\": 0,\n      \"map_id\": \"\"\n    },\n    \"snap_to_path\": false\n  },\n  \"wayfinding_path\": {\n    \"coordinate\": \"\",\n    \"nodes\": [\n      {}\n    ]\n  },\n  \"width\": \"\",\n  \"width_m\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id";

    let payload = json!({
        "created_time": "",
        "flags": json!({}),
        "for_site": false,
        "height": "",
        "height_m": "",
        "id": "",
        "latlng_br": json!({
            "lat": "",
            "lng": ""
        }),
        "latlng_tl": json!({
            "lat": "",
            "lng": ""
        }),
        "locked": false,
        "modified_time": "",
        "name": "",
        "occupancy_limit": 0,
        "org_id": "",
        "orientation": "",
        "origin_x": "",
        "origin_y": "",
        "ppm": "",
        "site_id": "",
        "sitesurvey_path": (
            json!({
                "coordinate": "",
                "id": "",
                "name": "",
                "nodes": (
                    json!({
                        "edges": json!({}),
                        "name": "",
                        "position": json!({
                            "x": "",
                            "y": ""
                        })
                    })
                )
            })
        ),
        "thumbnail_url": "",
        "type": "",
        "url": "",
        "use_auto_orientation": false,
        "use_auto_placement": false,
        "view": "",
        "wall_path": json!({
            "coordinate": "",
            "name": "",
            "nodes": (json!({}))
        }),
        "wayfinding": json!({
            "micello": json!({
                "account_key": "",
                "default_level_id": 0,
                "map_id": ""
            }),
            "snap_to_path": false
        }),
        "wayfinding_path": json!({
            "coordinate": "",
            "nodes": (json!({}))
        }),
        "width": "",
        "width_m": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "created_time": "",
  "flags": {},
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": {
    "lat": "",
    "lng": ""
  },
  "latlng_tl": {
    "lat": "",
    "lng": ""
  },
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    {
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        {
          "edges": {},
          "name": "",
          "position": {
            "x": "",
            "y": ""
          }
        }
      ]
    }
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": {
    "coordinate": "",
    "name": "",
    "nodes": [
      {}
    ]
  },
  "wayfinding": {
    "micello": {
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    },
    "snap_to_path": false
  },
  "wayfinding_path": {
    "coordinate": "",
    "nodes": [
      {}
    ]
  },
  "width": "",
  "width_m": ""
}' |  \
  http PUT {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "created_time": "",\n  "flags": {},\n  "for_site": false,\n  "height": "",\n  "height_m": "",\n  "id": "",\n  "latlng_br": {\n    "lat": "",\n    "lng": ""\n  },\n  "latlng_tl": {\n    "lat": "",\n    "lng": ""\n  },\n  "locked": false,\n  "modified_time": "",\n  "name": "",\n  "occupancy_limit": 0,\n  "org_id": "",\n  "orientation": "",\n  "origin_x": "",\n  "origin_y": "",\n  "ppm": "",\n  "site_id": "",\n  "sitesurvey_path": [\n    {\n      "coordinate": "",\n      "id": "",\n      "name": "",\n      "nodes": [\n        {\n          "edges": {},\n          "name": "",\n          "position": {\n            "x": "",\n            "y": ""\n          }\n        }\n      ]\n    }\n  ],\n  "thumbnail_url": "",\n  "type": "",\n  "url": "",\n  "use_auto_orientation": false,\n  "use_auto_placement": false,\n  "view": "",\n  "wall_path": {\n    "coordinate": "",\n    "name": "",\n    "nodes": [\n      {}\n    ]\n  },\n  "wayfinding": {\n    "micello": {\n      "account_key": "",\n      "default_level_id": 0,\n      "map_id": ""\n    },\n    "snap_to_path": false\n  },\n  "wayfinding_path": {\n    "coordinate": "",\n    "nodes": [\n      {}\n    ]\n  },\n  "width": "",\n  "width_m": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "created_time": "",
  "flags": [],
  "for_site": false,
  "height": "",
  "height_m": "",
  "id": "",
  "latlng_br": [
    "lat": "",
    "lng": ""
  ],
  "latlng_tl": [
    "lat": "",
    "lng": ""
  ],
  "locked": false,
  "modified_time": "",
  "name": "",
  "occupancy_limit": 0,
  "org_id": "",
  "orientation": "",
  "origin_x": "",
  "origin_y": "",
  "ppm": "",
  "site_id": "",
  "sitesurvey_path": [
    [
      "coordinate": "",
      "id": "",
      "name": "",
      "nodes": [
        [
          "edges": [],
          "name": "",
          "position": [
            "x": "",
            "y": ""
          ]
        ]
      ]
    ]
  ],
  "thumbnail_url": "",
  "type": "",
  "url": "",
  "use_auto_orientation": false,
  "use_auto_placement": false,
  "view": "",
  "wall_path": [
    "coordinate": "",
    "name": "",
    "nodes": [[]]
  ],
  "wayfinding": [
    "micello": [
      "account_key": "",
      "default_level_id": 0,
      "map_id": ""
    ],
    "snap_to_path": false
  ],
  "wayfinding_path": [
    "coordinate": "",
    "nodes": [[]]
  ],
  "width": "",
  "width_m": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/installer/orgs/:org_id/sites/:site_name/maps/:map_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/login");

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  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/login" {:content-type :json
                                                         :form-params {:email ""
                                                                       :password ""
                                                                       :two_factor ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/login"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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}}/api/v1/login"),
    Content = new StringContent("{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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}}/api/v1/login");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/login"

	payload := strings.NewReader("{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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/api/v1/login HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 55

{
  "email": "",
  "password": "",
  "two_factor": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/login")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/login"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/login")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/login")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  email: '',
  password: '',
  two_factor: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/login');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login',
  headers: {'content-type': 'application/json'},
  data: {email: '', password: '', two_factor: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"","password":"","two_factor":""}'
};

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}}/api/v1/login',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": "",\n  "password": "",\n  "two_factor": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/login")
  .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/api/v1/login',
  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({email: '', password: '', two_factor: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login',
  headers: {'content-type': 'application/json'},
  body: {email: '', password: '', two_factor: ''},
  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}}/api/v1/login');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: '',
  password: '',
  two_factor: ''
});

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}}/api/v1/login',
  headers: {'content-type': 'application/json'},
  data: {email: '', password: '', two_factor: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/login';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":"","password":"","two_factor":""}'
};

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 = @{ @"email": @"",
                              @"password": @"",
                              @"two_factor": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/login"]
                                                       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}}/api/v1/login" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/login",
  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([
    'email' => '',
    'password' => '',
    'two_factor' => ''
  ]),
  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}}/api/v1/login', [
  'body' => '{
  "email": "",
  "password": "",
  "two_factor": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/login');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => '',
  'password' => '',
  'two_factor' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => '',
  'password' => '',
  'two_factor' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/login');
$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}}/api/v1/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "password": "",
  "two_factor": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/login' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": "",
  "password": "",
  "two_factor": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/login", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/login"

payload = {
    "email": "",
    "password": "",
    "two_factor": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/login"

payload <- "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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}}/api/v1/login")

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  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\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/api/v1/login') do |req|
  req.body = "{\n  \"email\": \"\",\n  \"password\": \"\",\n  \"two_factor\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/login";

    let payload = json!({
        "email": "",
        "password": "",
        "two_factor": ""
    });

    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 '{
  "email": "",
  "password": "",
  "two_factor": ""
}' |  \
  http POST {{baseUrl}}/api/v1/login \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": "",\n  "password": "",\n  "two_factor": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/login

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "email": "",
  "password": "",
  "two_factor": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/login")! 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}}/api/v1/logout");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/logout")

require "http/client"

url = "{{baseUrl}}/api/v1/logout"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/v1/logout"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/logout");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/logout"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/v1/logout HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/logout")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/logout"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/logout")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/logout")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/logout');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/v1/logout'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/logout';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/logout',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/logout")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/logout',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/api/v1/logout'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/logout');

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}}/api/v1/logout'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/logout';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/logout"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/v1/logout" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/logout",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/v1/logout');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/logout');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/logout');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/logout' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/logout' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/v1/logout")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/logout"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/logout"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/logout")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/v1/logout') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/logout";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/api/v1/logout

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/v1/logout

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/logout")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/login/lookup");

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  \"email\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/login/lookup" {:content-type :json
                                                                :form-params {:email ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/login/lookup"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"email\": \"\"\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}}/api/v1/login/lookup"),
    Content = new StringContent("{\n  \"email\": \"\"\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}}/api/v1/login/lookup");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"email\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/login/lookup"

	payload := strings.NewReader("{\n  \"email\": \"\"\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/api/v1/login/lookup HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 17

{
  "email": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/login/lookup")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"email\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/login/lookup"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"email\": \"\"\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  \"email\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/login/lookup")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/login/lookup")
  .header("content-type", "application/json")
  .body("{\n  \"email\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  email: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/login/lookup');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/lookup',
  headers: {'content-type': 'application/json'},
  data: {email: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/login/lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":""}'
};

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}}/api/v1/login/lookup',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "email": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"email\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/login/lookup")
  .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/api/v1/login/lookup',
  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({email: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/lookup',
  headers: {'content-type': 'application/json'},
  body: {email: ''},
  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}}/api/v1/login/lookup');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  email: ''
});

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}}/api/v1/login/lookup',
  headers: {'content-type': 'application/json'},
  data: {email: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/login/lookup';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"email":""}'
};

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 = @{ @"email": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/login/lookup"]
                                                       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}}/api/v1/login/lookup" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"email\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/login/lookup",
  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([
    'email' => ''
  ]),
  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}}/api/v1/login/lookup', [
  'body' => '{
  "email": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/login/lookup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'email' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'email' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/login/lookup');
$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}}/api/v1/login/lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/login/lookup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "email": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"email\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/login/lookup", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/login/lookup"

payload = { "email": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/login/lookup"

payload <- "{\n  \"email\": \"\"\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}}/api/v1/login/lookup")

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  \"email\": \"\"\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/api/v1/login/lookup') do |req|
  req.body = "{\n  \"email\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/login/lookup";

    let payload = json!({"email": ""});

    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 '{
  "email": ""
}' |  \
  http POST {{baseUrl}}/api/v1/login/lookup \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "email": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/login/lookup

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["email": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/login/lookup")! 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}}/api/v1/login/oauth/:provider");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/login/oauth/:provider")

require "http/client"

url = "{{baseUrl}}/api/v1/login/oauth/:provider"

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}}/api/v1/login/oauth/:provider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/login/oauth/:provider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/login/oauth/:provider"

	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/api/v1/login/oauth/:provider HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/login/oauth/:provider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/login/oauth/:provider"))
    .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}}/api/v1/login/oauth/:provider")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/login/oauth/:provider")
  .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}}/api/v1/login/oauth/:provider');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/login/oauth/:provider'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/login/oauth/:provider';
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}}/api/v1/login/oauth/:provider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/login/oauth/:provider")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/login/oauth/:provider',
  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}}/api/v1/login/oauth/:provider'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/login/oauth/:provider');

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}}/api/v1/login/oauth/:provider'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/login/oauth/:provider';
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}}/api/v1/login/oauth/:provider"]
                                                       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}}/api/v1/login/oauth/:provider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/login/oauth/:provider",
  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}}/api/v1/login/oauth/:provider');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/login/oauth/:provider');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/login/oauth/:provider');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/login/oauth/:provider' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/login/oauth/:provider' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/login/oauth/:provider")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/login/oauth/:provider"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/login/oauth/:provider"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/login/oauth/:provider")

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/api/v1/login/oauth/:provider') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/login/oauth/:provider";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/login/oauth/:provider

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/login/oauth/:provider

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/login/oauth/:provider")! 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}}/api/v1/self/oauth/:provider");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/self/oauth/:provider")

require "http/client"

url = "{{baseUrl}}/api/v1/self/oauth/:provider"

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}}/api/v1/self/oauth/:provider"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/v1/self/oauth/:provider");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/self/oauth/:provider"

	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/api/v1/self/oauth/:provider HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/self/oauth/:provider")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/self/oauth/:provider"))
    .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}}/api/v1/self/oauth/:provider")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/self/oauth/:provider")
  .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}}/api/v1/self/oauth/:provider');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/v1/self/oauth/:provider'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/self/oauth/:provider';
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}}/api/v1/self/oauth/:provider',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/self/oauth/:provider")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/self/oauth/:provider',
  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}}/api/v1/self/oauth/:provider'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/self/oauth/:provider');

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}}/api/v1/self/oauth/:provider'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/self/oauth/:provider';
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}}/api/v1/self/oauth/:provider"]
                                                       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}}/api/v1/self/oauth/:provider" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/self/oauth/:provider",
  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}}/api/v1/self/oauth/:provider');

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/self/oauth/:provider');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/v1/self/oauth/:provider');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/self/oauth/:provider' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/self/oauth/:provider' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/v1/self/oauth/:provider")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/self/oauth/:provider"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/self/oauth/:provider"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/self/oauth/:provider")

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/api/v1/self/oauth/:provider') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/self/oauth/:provider";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/api/v1/self/oauth/:provider

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/v1/self/oauth/:provider

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/self/oauth/:provider")! 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}}/api/v1/self/oauth/:provider");

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  \"code\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/self/oauth/:provider" {:content-type :json
                                                                        :form-params {:code ""}})

require "http/client"

url = "{{baseUrl}}/api/v1/self/oauth/:provider"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": \"\"\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}}/api/v1/self/oauth/:provider"),
    Content = new StringContent("{\n  \"code\": \"\"\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}}/api/v1/self/oauth/:provider");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/self/oauth/:provider"

	payload := strings.NewReader("{\n  \"code\": \"\"\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/api/v1/self/oauth/:provider HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "code": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/self/oauth/:provider")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/self/oauth/:provider"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": \"\"\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  \"code\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/self/oauth/:provider")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/self/oauth/:provider")
  .header("content-type", "application/json")
  .body("{\n  \"code\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  code: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/self/oauth/:provider');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/self/oauth/:provider',
  headers: {'content-type': 'application/json'},
  data: {code: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/self/oauth/:provider';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":""}'
};

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}}/api/v1/self/oauth/:provider',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"code\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/self/oauth/:provider")
  .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/api/v1/self/oauth/:provider',
  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({code: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/self/oauth/:provider',
  headers: {'content-type': 'application/json'},
  body: {code: ''},
  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}}/api/v1/self/oauth/:provider');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: ''
});

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}}/api/v1/self/oauth/:provider',
  headers: {'content-type': 'application/json'},
  data: {code: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/self/oauth/:provider';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":""}'
};

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 = @{ @"code": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/self/oauth/:provider"]
                                                       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}}/api/v1/self/oauth/:provider" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/self/oauth/:provider",
  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([
    'code' => ''
  ]),
  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}}/api/v1/self/oauth/:provider', [
  'body' => '{
  "code": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/self/oauth/:provider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/self/oauth/:provider');
$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}}/api/v1/self/oauth/:provider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/self/oauth/:provider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/self/oauth/:provider", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/self/oauth/:provider"

payload = { "code": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/self/oauth/:provider"

payload <- "{\n  \"code\": \"\"\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}}/api/v1/self/oauth/:provider")

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  \"code\": \"\"\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/api/v1/self/oauth/:provider') do |req|
  req.body = "{\n  \"code\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/self/oauth/:provider";

    let payload = json!({"code": ""});

    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 '{
  "code": ""
}' |  \
  http POST {{baseUrl}}/api/v1/self/oauth/:provider \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/self/oauth/:provider

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["code": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/self/oauth/:provider")! 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}}/api/v1/login/oauth/:provider");

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  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/login/oauth/:provider" {:content-type :json
                                                                         :form-params {:code "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"}})

require "http/client"

url = "{{baseUrl}}/api/v1/login/oauth/:provider"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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}}/api/v1/login/oauth/:provider"),
    Content = new StringContent("{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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}}/api/v1/login/oauth/:provider");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/login/oauth/:provider"

	payload := strings.NewReader("{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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/api/v1/login/oauth/:provider HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/login/oauth/:provider")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/login/oauth/:provider"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/login/oauth/:provider")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/login/oauth/:provider")
  .header("content-type", "application/json")
  .body("{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}")
  .asString();

const data = JSON.stringify({
  code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/login/oauth/:provider');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/oauth/:provider',
  headers: {'content-type': 'application/json'},
  data: {code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/login/oauth/:provider';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"}'
};

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}}/api/v1/login/oauth/:provider',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/login/oauth/:provider")
  .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/api/v1/login/oauth/:provider',
  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({code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/oauth/:provider',
  headers: {'content-type': 'application/json'},
  body: {code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'},
  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}}/api/v1/login/oauth/:provider');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'
});

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}}/api/v1/login/oauth/:provider',
  headers: {'content-type': 'application/json'},
  data: {code: '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/login/oauth/:provider';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"code":"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"}'
};

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 = @{ @"code": @"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/login/oauth/:provider"]
                                                       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}}/api/v1/login/oauth/:provider" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/login/oauth/:provider",
  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([
    'code' => '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'
  ]),
  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}}/api/v1/login/oauth/:provider', [
  'body' => '{
  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/login/oauth/:provider');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'code' => '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'code' => '4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw'
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/login/oauth/:provider');
$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}}/api/v1/login/oauth/:provider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/login/oauth/:provider' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/login/oauth/:provider", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/login/oauth/:provider"

payload = { "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/login/oauth/:provider"

payload <- "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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}}/api/v1/login/oauth/:provider")

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  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\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/api/v1/login/oauth/:provider') do |req|
  req.body = "{\n  \"code\": \"4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/login/oauth/:provider";

    let payload = json!({"code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"});

    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 '{
  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"
}' |  \
  http POST {{baseUrl}}/api/v1/login/oauth/:provider \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/login/oauth/:provider

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["code": "4/S9tegDeLkrYg0L9pWNXV4cgMVbbr3SR9t693A2kSHzw"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/login/oauth/:provider")! 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}}/api/v1/login/two_factor");

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  \"two_factor\": \"123456\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/login/two_factor" {:content-type :json
                                                                    :form-params {:two_factor "123456"}})

require "http/client"

url = "{{baseUrl}}/api/v1/login/two_factor"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"two_factor\": \"123456\"\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}}/api/v1/login/two_factor"),
    Content = new StringContent("{\n  \"two_factor\": \"123456\"\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}}/api/v1/login/two_factor");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"two_factor\": \"123456\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/v1/login/two_factor"

	payload := strings.NewReader("{\n  \"two_factor\": \"123456\"\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/api/v1/login/two_factor HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "two_factor": "123456"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/login/two_factor")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"two_factor\": \"123456\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/login/two_factor"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"two_factor\": \"123456\"\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  \"two_factor\": \"123456\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/login/two_factor")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/login/two_factor")
  .header("content-type", "application/json")
  .body("{\n  \"two_factor\": \"123456\"\n}")
  .asString();

const data = JSON.stringify({
  two_factor: '123456'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/v1/login/two_factor');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/two_factor',
  headers: {'content-type': 'application/json'},
  data: {two_factor: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/v1/login/two_factor';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"two_factor":"123456"}'
};

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}}/api/v1/login/two_factor',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "two_factor": "123456"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"two_factor\": \"123456\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/login/two_factor")
  .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/api/v1/login/two_factor',
  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({two_factor: '123456'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/login/two_factor',
  headers: {'content-type': 'application/json'},
  body: {two_factor: '123456'},
  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}}/api/v1/login/two_factor');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  two_factor: '123456'
});

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}}/api/v1/login/two_factor',
  headers: {'content-type': 'application/json'},
  data: {two_factor: '123456'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/login/two_factor';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"two_factor":"123456"}'
};

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 = @{ @"two_factor": @"123456" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/login/two_factor"]
                                                       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}}/api/v1/login/two_factor" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"two_factor\": \"123456\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/v1/login/two_factor",
  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([
    'two_factor' => '123456'
  ]),
  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}}/api/v1/login/two_factor', [
  'body' => '{
  "two_factor": "123456"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/v1/login/two_factor');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'two_factor' => '123456'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'two_factor' => '123456'
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/login/two_factor');
$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}}/api/v1/login/two_factor' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "two_factor": "123456"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/login/two_factor' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "two_factor": "123456"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"two_factor\": \"123456\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/v1/login/two_factor", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/v1/login/two_factor"

payload = { "two_factor": "123456" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/v1/login/two_factor"

payload <- "{\n  \"two_factor\": \"123456\"\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}}/api/v1/login/two_factor")

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  \"two_factor\": \"123456\"\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/api/v1/login/two_factor') do |req|
  req.body = "{\n  \"two_factor\": \"123456\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/v1/login/two_factor";

    let payload = json!({"two_factor": "123456"});

    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 '{
  "two_factor": "123456"
}' |  \
  http POST {{baseUrl}}/api/v1/login/two_factor \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "two_factor": "123456"\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/login/two_factor

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["two_factor": "123456"] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/login/two_factor")! 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()